use syntax::feature_gate::{BUILTIN_ATTRIBUTES, AttributeType};
use syntax::symbol::keywords;
use syntax::ptr::P;
+use syntax::util::parser;
use syntax_pos::Span;
use rustc_back::slice;
msg: &str,
struct_lit_needs_parens: bool) {
if let ast::ExprKind::Paren(ref inner) = value.node {
- let necessary = struct_lit_needs_parens && contains_exterior_struct_lit(&inner);
+ let necessary = struct_lit_needs_parens &&
+ parser::contains_exterior_struct_lit(&inner);
if !necessary {
cx.span_lint(UNUSED_PARENS,
value.span,
&format!("unnecessary parentheses around {}", msg))
}
}
-
- /// Expressions that syntactically contain an "exterior" struct
- /// literal i.e. not surrounded by any parens or other
- /// delimiters, e.g. `X { y: 1 }`, `X { y: 1 }.method()`, `foo
- /// == X { y: 1 }` and `X { y: 1 } == foo` all do, but `(X {
- /// y: 1 }) == foo` does not.
- fn contains_exterior_struct_lit(value: &ast::Expr) -> bool {
- match value.node {
- ast::ExprKind::Struct(..) => true,
-
- ast::ExprKind::Assign(ref lhs, ref rhs) |
- ast::ExprKind::AssignOp(_, ref lhs, ref rhs) |
- ast::ExprKind::Binary(_, ref lhs, ref rhs) => {
- // X { y: 1 } + X { y: 2 }
- contains_exterior_struct_lit(&lhs) || contains_exterior_struct_lit(&rhs)
- }
- ast::ExprKind::Unary(_, ref x) |
- ast::ExprKind::Cast(ref x, _) |
- ast::ExprKind::Type(ref x, _) |
- ast::ExprKind::Field(ref x, _) |
- ast::ExprKind::TupField(ref x, _) |
- ast::ExprKind::Index(ref x, _) => {
- // &X { y: 1 }, X { y: 1 }.y
- contains_exterior_struct_lit(&x)
- }
-
- ast::ExprKind::MethodCall(.., ref exprs) => {
- // X { y: 1 }.bar(...)
- contains_exterior_struct_lit(&exprs[0])
- }
-
- _ => false,
- }
- }
}
}
use ast::{self, BlockCheckMode, PatKind, RangeEnd};
use ast::{SelfKind, RegionTyParamBound, TraitTyParamBound, TraitBoundModifier};
use ast::Attribute;
-use util::parser::AssocOp;
+use util::parser::{self, AssocOp, Fixity};
use attr;
use codemap::{self, CodeMap};
use syntax_pos::{self, BytePos};
format!("{}{}", to_string(|s| s.print_visibility(vis)), s)
}
-fn needs_parentheses(expr: &ast::Expr) -> bool {
- match expr.node {
- ast::ExprKind::Assign(..) | ast::ExprKind::Binary(..) |
- ast::ExprKind::Closure(..) |
- ast::ExprKind::AssignOp(..) | ast::ExprKind::Cast(..) |
- ast::ExprKind::InPlace(..) | ast::ExprKind::Type(..) => true,
- _ => false,
- }
-}
-
pub trait PrintState<'a> {
fn writer(&mut self) -> &mut pp::Printer<'a>;
fn boxes(&mut self) -> &mut Vec<pp::Breaks>;
self.cbox(INDENT_UNIT - 1)?;
self.ibox(0)?;
self.s.word(" else if ")?;
- self.print_expr(i)?;
+ self.print_expr_as_cond(i)?;
self.s.space()?;
self.print_block(then)?;
self.print_else(e.as_ref().map(|e| &**e))
self.print_pat(pat)?;
self.s.space()?;
self.word_space("=")?;
- self.print_expr(expr)?;
+ self.print_expr_as_cond(expr)?;
self.s.space()?;
self.print_block(then)?;
self.print_else(e.as_ref().map(|e| &**e))
pub fn print_if(&mut self, test: &ast::Expr, blk: &ast::Block,
elseopt: Option<&ast::Expr>) -> io::Result<()> {
self.head("if")?;
- self.print_expr(test)?;
+ self.print_expr_as_cond(test)?;
self.s.space()?;
self.print_block(blk)?;
self.print_else(elseopt)
self.print_pat(pat)?;
self.s.space()?;
self.word_space("=")?;
- self.print_expr(expr)?;
+ self.print_expr_as_cond(expr)?;
self.s.space()?;
self.print_block(blk)?;
self.print_else(elseopt)
self.pclose()
}
- pub fn check_expr_bin_needs_paren(&mut self, sub_expr: &ast::Expr,
- binop: ast::BinOp) -> bool {
- match sub_expr.node {
- ast::ExprKind::Binary(ref sub_op, _, _) => {
- AssocOp::from_ast_binop(sub_op.node).precedence() <
- AssocOp::from_ast_binop(binop.node).precedence()
- }
- _ => true
+ pub fn print_expr_maybe_paren(&mut self, expr: &ast::Expr, prec: i8) -> io::Result<()> {
+ let needs_par = parser::expr_precedence(expr) < prec;
+ if needs_par {
+ self.popen()?;
}
+ self.print_expr(expr)?;
+ if needs_par {
+ self.pclose()?;
+ }
+ Ok(())
}
- pub fn print_expr_maybe_paren(&mut self, expr: &ast::Expr) -> io::Result<()> {
- let needs_par = needs_parentheses(expr);
+ /// Print an expr using syntax that's acceptable in a condition position, such as the `cond` in
+ /// `if cond { ... }`.
+ pub fn print_expr_as_cond(&mut self, expr: &ast::Expr) -> io::Result<()> {
+ let needs_par = match expr.node {
+ // These cases need parens due to the parse error observed in #26461: `if return {}`
+ // parses as the erroneous construct `if (return {})`, not `if (return) {}`.
+ ast::ExprKind::Closure(..) |
+ ast::ExprKind::Ret(..) |
+ ast::ExprKind::Break(..) => true,
+
+ _ => parser::contains_exterior_struct_lit(expr),
+ };
+
if needs_par {
self.popen()?;
}
fn print_expr_in_place(&mut self,
place: &ast::Expr,
expr: &ast::Expr) -> io::Result<()> {
- self.print_expr_maybe_paren(place)?;
+ let prec = AssocOp::Inplace.precedence() as i8;
+ self.print_expr_maybe_paren(place, prec + 1)?;
self.s.space()?;
self.word_space("<-")?;
- self.print_expr_maybe_paren(expr)
+ self.print_expr_maybe_paren(expr, prec)
}
fn print_expr_vec(&mut self, exprs: &[P<ast::Expr>],
fn print_expr_call(&mut self,
func: &ast::Expr,
args: &[P<ast::Expr>]) -> io::Result<()> {
- self.print_expr_maybe_paren(func)?;
+ let prec =
+ match func.node {
+ ast::ExprKind::Field(..) |
+ ast::ExprKind::TupField(..) => parser::PREC_FORCE_PAREN,
+ _ => parser::PREC_POSTFIX,
+ };
+
+ self.print_expr_maybe_paren(func, prec)?;
self.print_call_post(args)
}
segment: &ast::PathSegment,
args: &[P<ast::Expr>]) -> io::Result<()> {
let base_args = &args[1..];
- self.print_expr(&args[0])?;
+ self.print_expr_maybe_paren(&args[0], parser::PREC_POSTFIX)?;
self.s.word(".")?;
self.print_ident(segment.identifier)?;
if let Some(ref parameters) = segment.parameters {
op: ast::BinOp,
lhs: &ast::Expr,
rhs: &ast::Expr) -> io::Result<()> {
- if self.check_expr_bin_needs_paren(lhs, op) {
- self.print_expr_maybe_paren(lhs)?;
- } else {
- self.print_expr(lhs)?;
- }
+ let assoc_op = AssocOp::from_ast_binop(op.node);
+ let prec = assoc_op.precedence() as i8;
+ let fixity = assoc_op.fixity();
+
+ let (left_prec, right_prec) = match fixity {
+ Fixity::Left => (prec, prec + 1),
+ Fixity::Right => (prec + 1, prec),
+ Fixity::None => (prec + 1, prec + 1),
+ };
+
+ self.print_expr_maybe_paren(lhs, left_prec)?;
self.s.space()?;
self.word_space(op.node.to_string())?;
- if self.check_expr_bin_needs_paren(rhs, op) {
- self.print_expr_maybe_paren(rhs)
- } else {
- self.print_expr(rhs)
- }
+ self.print_expr_maybe_paren(rhs, right_prec)
}
fn print_expr_unary(&mut self,
op: ast::UnOp,
expr: &ast::Expr) -> io::Result<()> {
self.s.word(ast::UnOp::to_string(op))?;
- self.print_expr_maybe_paren(expr)
+ self.print_expr_maybe_paren(expr, parser::PREC_PREFIX)
}
fn print_expr_addr_of(&mut self,
expr: &ast::Expr) -> io::Result<()> {
self.s.word("&")?;
self.print_mutability(mutability)?;
- self.print_expr_maybe_paren(expr)
+ self.print_expr_maybe_paren(expr, parser::PREC_PREFIX)
}
pub fn print_expr(&mut self, expr: &ast::Expr) -> io::Result<()> {
match expr.node {
ast::ExprKind::Box(ref expr) => {
self.word_space("box")?;
- self.print_expr(expr)?;
+ self.print_expr_maybe_paren(expr, parser::PREC_PREFIX)?;
}
ast::ExprKind::InPlace(ref place, ref expr) => {
self.print_expr_in_place(place, expr)?;
self.print_literal(lit)?;
}
ast::ExprKind::Cast(ref expr, ref ty) => {
- if let ast::ExprKind::Cast(..) = expr.node {
- self.print_expr(expr)?;
- } else {
- self.print_expr_maybe_paren(expr)?;
- }
+ let prec = AssocOp::As.precedence() as i8;
+ self.print_expr_maybe_paren(expr, prec)?;
self.s.space()?;
self.word_space("as")?;
self.print_type(ty)?;
}
ast::ExprKind::Type(ref expr, ref ty) => {
- self.print_expr(expr)?;
+ let prec = AssocOp::Colon.precedence() as i8;
+ self.print_expr_maybe_paren(expr, prec)?;
self.word_space(":")?;
self.print_type(ty)?;
}
self.word_space(":")?;
}
self.head("while")?;
- self.print_expr(test)?;
+ self.print_expr_as_cond(test)?;
self.s.space()?;
self.print_block_with_attrs(blk, attrs)?;
}
self.print_pat(pat)?;
self.s.space()?;
self.word_space("=")?;
- self.print_expr(expr)?;
+ self.print_expr_as_cond(expr)?;
self.s.space()?;
self.print_block_with_attrs(blk, attrs)?;
}
self.print_pat(pat)?;
self.s.space()?;
self.word_space("in")?;
- self.print_expr(iter)?;
+ self.print_expr_as_cond(iter)?;
self.s.space()?;
self.print_block_with_attrs(blk, attrs)?;
}
self.cbox(INDENT_UNIT)?;
self.ibox(4)?;
self.word_nbsp("match")?;
- self.print_expr(expr)?;
+ self.print_expr_as_cond(expr)?;
self.s.space()?;
self.bopen()?;
self.print_inner_attributes_no_trailing_hardbreak(attrs)?;
self.print_block_with_attrs(blk, attrs)?;
}
ast::ExprKind::Assign(ref lhs, ref rhs) => {
- self.print_expr(lhs)?;
+ let prec = AssocOp::Assign.precedence() as i8;
+ self.print_expr_maybe_paren(lhs, prec + 1)?;
self.s.space()?;
self.word_space("=")?;
- self.print_expr(rhs)?;
+ self.print_expr_maybe_paren(rhs, prec)?;
}
ast::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
- self.print_expr(lhs)?;
+ let prec = AssocOp::Assign.precedence() as i8;
+ self.print_expr_maybe_paren(lhs, prec + 1)?;
self.s.space()?;
self.s.word(op.node.to_string())?;
self.word_space("=")?;
- self.print_expr(rhs)?;
+ self.print_expr_maybe_paren(rhs, prec)?;
}
ast::ExprKind::Field(ref expr, id) => {
- self.print_expr(expr)?;
+ self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX)?;
self.s.word(".")?;
self.print_ident(id.node)?;
}
ast::ExprKind::TupField(ref expr, id) => {
- self.print_expr(expr)?;
+ self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX)?;
self.s.word(".")?;
self.print_usize(id.node)?;
}
ast::ExprKind::Index(ref expr, ref index) => {
- self.print_expr(expr)?;
+ self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX)?;
self.s.word("[")?;
self.print_expr(index)?;
self.s.word("]")?;
}
ast::ExprKind::Range(ref start, ref end, limits) => {
+ // Special case for `Range`. `AssocOp` claims that `Range` has higher precedence
+ // than `Assign`, but `x .. x = x` gives a parse error instead of `x .. (x = x)`.
+ // Here we use a fake precedence value so that any child with lower precedence than
+ // a "normal" binop gets parenthesized. (`LOr` is the lowest-precedence binop.)
+ let fake_prec = AssocOp::LOr.precedence() as i8;
if let Some(ref e) = *start {
- self.print_expr(e)?;
+ self.print_expr_maybe_paren(e, fake_prec)?;
}
if limits == ast::RangeLimits::HalfOpen {
self.s.word("..")?;
self.s.word("...")?;
}
if let Some(ref e) = *end {
- self.print_expr(e)?;
+ self.print_expr_maybe_paren(e, fake_prec)?;
}
}
ast::ExprKind::Path(None, ref path) => {
self.s.space()?;
}
if let Some(ref expr) = *opt_expr {
- self.print_expr(expr)?;
+ self.print_expr_maybe_paren(expr, parser::PREC_JUMP)?;
self.s.space()?;
}
}
self.s.word("return")?;
if let Some(ref expr) = *result {
self.s.word(" ")?;
- self.print_expr(expr)?;
+ self.print_expr_maybe_paren(expr, parser::PREC_JUMP)?;
}
}
ast::ExprKind::InlineAsm(ref a) => {
match *e {
Some(ref expr) => {
self.s.space()?;
- self.print_expr(&expr)?;
+ self.print_expr_maybe_paren(expr, parser::PREC_JUMP)?;
}
_ => ()
}
}
ast::ExprKind::Try(ref e) => {
- self.print_expr(e)?;
+ self.print_expr_maybe_paren(e, parser::PREC_POSTFIX)?;
self.s.word("?")?
}
ast::ExprKind::Catch(ref blk) => {
// except according to those terms.
use parse::token::{Token, BinOpToken};
use symbol::keywords;
-use ast::BinOpKind;
+use ast::{self, BinOpKind, ExprKind};
/// Associative operator with precedence.
///
}
}
}
+
+pub const PREC_RESET: i8 = -100;
+pub const PREC_CLOSURE: i8 = -40;
+pub const PREC_JUMP: i8 = -30;
+pub const PREC_BLOCK: i8 = -20;
+pub const PREC_RANGE: i8 = -10;
+// The range 2 ... 14 is reserved for AssocOp binary operator precedences.
+pub const PREC_PREFIX: i8 = 50;
+pub const PREC_POSTFIX: i8 = 60;
+pub const PREC_PAREN: i8 = 99;
+pub const PREC_FORCE_PAREN: i8 = 100;
+
+pub fn expr_precedence(expr: &ast::Expr) -> i8 {
+ match expr.node {
+ ExprKind::Closure(..) => PREC_CLOSURE,
+
+ ExprKind::Break(..) |
+ ExprKind::Continue(..) |
+ ExprKind::Ret(..) |
+ ExprKind::Yield(..) => PREC_JUMP,
+
+ ExprKind::If(..) |
+ ExprKind::IfLet(..) |
+ ExprKind::While(..) |
+ ExprKind::WhileLet(..) |
+ ExprKind::ForLoop(..) |
+ ExprKind::Loop(..) |
+ ExprKind::Match(..) |
+ ExprKind::Block(..) |
+ ExprKind::Catch(..) => PREC_BLOCK,
+
+ // `Range` claims to have higher precedence than `Assign`, but `x .. x = x` fails to parse,
+ // instead of parsing as `(x .. x) = x`. Giving `Range` a lower precedence ensures that
+ // `pprust` will add parentheses in the right places to get the desired parse.
+ ExprKind::Range(..) => PREC_RANGE,
+
+ // Binop-like expr kinds, handled by `AssocOp`.
+ ExprKind::Binary(op, _, _) =>
+ AssocOp::from_ast_binop(op.node).precedence() as i8,
+
+ ExprKind::InPlace(..) => AssocOp::Inplace.precedence() as i8,
+ ExprKind::Cast(..) => AssocOp::As.precedence() as i8,
+ ExprKind::Type(..) => AssocOp::Colon.precedence() as i8,
+
+ ExprKind::Assign(..) |
+ ExprKind::AssignOp(..) => AssocOp::Assign.precedence() as i8,
+
+ // Unary, prefix
+ ExprKind::Box(..) |
+ ExprKind::AddrOf(..) |
+ ExprKind::Unary(..) => PREC_PREFIX,
+
+ // Unary, postfix
+ ExprKind::Call(..) |
+ ExprKind::MethodCall(..) |
+ ExprKind::Field(..) |
+ ExprKind::TupField(..) |
+ ExprKind::Index(..) |
+ ExprKind::Try(..) |
+ ExprKind::InlineAsm(..) |
+ ExprKind::Mac(..) => PREC_POSTFIX,
+
+ // Never need parens
+ ExprKind::Array(..) |
+ ExprKind::Repeat(..) |
+ ExprKind::Tup(..) |
+ ExprKind::Lit(..) |
+ ExprKind::Path(..) |
+ ExprKind::Paren(..) |
+ ExprKind::Struct(..) => PREC_PAREN,
+ }
+}
+
+/// Expressions that syntactically contain an "exterior" struct literal i.e. not surrounded by any
+/// parens or other delimiters, e.g. `X { y: 1 }`, `X { y: 1 }.method()`, `foo == X { y: 1 }` and
+/// `X { y: 1 } == foo` all do, but `(X { y: 1 }) == foo` does not.
+pub fn contains_exterior_struct_lit(value: &ast::Expr) -> bool {
+ match value.node {
+ ast::ExprKind::Struct(..) => true,
+
+ ast::ExprKind::Assign(ref lhs, ref rhs) |
+ ast::ExprKind::AssignOp(_, ref lhs, ref rhs) |
+ ast::ExprKind::Binary(_, ref lhs, ref rhs) => {
+ // X { y: 1 } + X { y: 2 }
+ contains_exterior_struct_lit(&lhs) || contains_exterior_struct_lit(&rhs)
+ }
+ ast::ExprKind::Unary(_, ref x) |
+ ast::ExprKind::Cast(ref x, _) |
+ ast::ExprKind::Type(ref x, _) |
+ ast::ExprKind::Field(ref x, _) |
+ ast::ExprKind::TupField(ref x, _) |
+ ast::ExprKind::Index(ref x, _) => {
+ // &X { y: 1 }, X { y: 1 }.y
+ contains_exterior_struct_lit(&x)
+ }
+
+ ast::ExprKind::MethodCall(.., ref exprs) => {
+ // X { y: 1 }.bar(...)
+ contains_exterior_struct_lit(&exprs[0])
+ }
+
+ _ => false,
+ }
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// ignore-cross-compile
+
+#![feature(rustc_private)]
+
+extern crate syntax;
+
+use syntax::ast::*;
+use syntax::codemap::{Spanned, DUMMY_SP};
+use syntax::codemap::FilePathMapping;
+use syntax::fold::{self, Folder};
+use syntax::parse::{self, ParseSess};
+use syntax::print::pprust;
+use syntax::ptr::P;
+use syntax::util::ThinVec;
+
+
+fn parse_expr(ps: &ParseSess, src: &str) -> P<Expr> {
+ let mut p = parse::new_parser_from_source_str(ps,
+ "<expr>".to_owned(),
+ src.to_owned());
+ p.parse_expr().unwrap()
+}
+
+
+// Helper functions for building exprs
+fn expr(kind: ExprKind) -> P<Expr> {
+ P(Expr {
+ id: DUMMY_NODE_ID,
+ node: kind,
+ span: DUMMY_SP,
+ attrs: ThinVec::new(),
+ })
+}
+
+fn make_x() -> P<Expr> {
+ let seg = PathSegment {
+ identifier: Ident::from_str("x"),
+ span: DUMMY_SP,
+ parameters: None,
+ };
+ let path = Path {
+ span: DUMMY_SP,
+ segments: vec![seg],
+ };
+ expr(ExprKind::Path(None, path))
+}
+
+/// Iterate over exprs of depth up to `depth`. The goal is to explore all "interesting"
+/// combinations of expression nesting. For example, we explore combinations using `if`, but not
+/// `while` or `match`, since those should print and parse in much the same way as `if`.
+fn iter_exprs(depth: usize, f: &mut FnMut(P<Expr>)) {
+ if depth == 0 {
+ f(make_x());
+ return;
+ }
+
+ let mut g = |e| f(expr(e));
+
+ for kind in 0 .. 17 {
+ match kind {
+ 0 => iter_exprs(depth - 1, &mut |e| g(ExprKind::Box(e))),
+ 1 => {
+ // Note that for binary expressions, we explore each side separately. The
+ // parenthesization decisions for the LHS and RHS should be independent, and this
+ // way produces `O(n)` results instead of `O(n^2)`.
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::InPlace(e, make_x())));
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::InPlace(make_x(), e)));
+ },
+ 2 => iter_exprs(depth - 1, &mut |e| g(ExprKind::Call(e, vec![]))),
+ 3 => {
+ let seg = PathSegment {
+ identifier: Ident::from_str("x"),
+ span: DUMMY_SP,
+ parameters: None,
+ };
+
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::MethodCall(
+ seg.clone(), vec![e, make_x()])));
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::MethodCall(
+ seg.clone(), vec![make_x(), e])));
+ },
+ 4 => {
+ let op = Spanned { span: DUMMY_SP, node: BinOpKind::Add };
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Binary(op, e, make_x())));
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Binary(op, make_x(), e)));
+ },
+ 5 => {
+ let op = Spanned { span: DUMMY_SP, node: BinOpKind::Mul };
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Binary(op, e, make_x())));
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Binary(op, make_x(), e)));
+ },
+ 6 => {
+ let op = Spanned { span: DUMMY_SP, node: BinOpKind::Shl };
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Binary(op, e, make_x())));
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Binary(op, make_x(), e)));
+ },
+ 7 => {
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Unary(UnOp::Deref, e)));
+ },
+ 8 => {
+ let block = P(Block {
+ stmts: Vec::new(),
+ id: DUMMY_NODE_ID,
+ rules: BlockCheckMode::Default,
+ span: DUMMY_SP,
+ });
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::If(e, block.clone(), None)));
+ },
+ 9 => {
+ let decl = P(FnDecl {
+ inputs: vec![],
+ output: FunctionRetTy::Default(DUMMY_SP),
+ variadic: false,
+ });
+ iter_exprs(depth - 1, &mut |e| g(
+ ExprKind::Closure(CaptureBy::Value, decl.clone(), e, DUMMY_SP)));
+ },
+ 10 => {
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Assign(e, make_x())));
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Assign(make_x(), e)));
+ },
+ 11 => {
+ let ident = Spanned { span: DUMMY_SP, node: Ident::from_str("f") };
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Field(e, ident)));
+ },
+ 12 => {
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Range(
+ Some(e), Some(make_x()), RangeLimits::HalfOpen)));
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Range(
+ Some(make_x()), Some(e), RangeLimits::HalfOpen)));
+ },
+ 13 => {
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::AddrOf(Mutability::Immutable, e)));
+ },
+ 14 => {
+ g(ExprKind::Ret(None));
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Ret(Some(e))));
+ },
+ 15 => {
+ let seg = PathSegment {
+ identifier: Ident::from_str("S"),
+ span: DUMMY_SP,
+ parameters: None,
+ };
+ let path = Path {
+ span: DUMMY_SP,
+ segments: vec![seg],
+ };
+ g(ExprKind::Struct(path, vec![], Some(make_x())));
+ },
+ 16 => {
+ iter_exprs(depth - 1, &mut |e| g(ExprKind::Try(e)));
+ },
+ _ => panic!("bad counter value in iter_exprs"),
+ }
+ }
+}
+
+
+// Folders for manipulating the placement of `Paren` nodes. See below for why this is needed.
+
+/// Folder that removes all `ExprKind::Paren` nodes.
+struct RemoveParens;
+
+impl Folder for RemoveParens {
+ fn fold_expr(&mut self, e: P<Expr>) -> P<Expr> {
+ let e = match e.node {
+ ExprKind::Paren(ref inner) => inner.clone(),
+ _ => e.clone(),
+ };
+ e.map(|e| fold::noop_fold_expr(e, self))
+ }
+}
+
+
+/// Folder that inserts `ExprKind::Paren` nodes around every `Expr`.
+struct AddParens;
+
+impl Folder for AddParens {
+ fn fold_expr(&mut self, e: P<Expr>) -> P<Expr> {
+ let e = e.map(|e| fold::noop_fold_expr(e, self));
+ P(Expr {
+ id: DUMMY_NODE_ID,
+ node: ExprKind::Paren(e),
+ span: DUMMY_SP,
+ attrs: ThinVec::new(),
+ })
+ }
+}
+
+
+fn main() {
+ let ps = ParseSess::new(FilePathMapping::empty());
+
+ iter_exprs(2, &mut |e| {
+ // If the pretty printer is correct, then `parse(print(e))` should be identical to `e`,
+ // modulo placement of `Paren` nodes.
+ let printed = pprust::expr_to_string(&e);
+ println!("printed: {}", printed);
+
+ let parsed = parse_expr(&ps, &printed);
+
+ // We want to know if `parsed` is structurally identical to `e`, ignoring trivial
+ // differences like placement of `Paren`s or the exact ranges of node spans.
+ // Unfortunately, there is no easy way to make this comparison. Instead, we add `Paren`s
+ // everywhere we can, then pretty-print. This should give an unambiguous representation of
+ // each `Expr`, and it bypasses nearly all of the parenthesization logic, so we aren't
+ // relying on the correctness of the very thing we're testing.
+ let e1 = AddParens.fold_expr(RemoveParens.fold_expr(e));
+ let text1 = pprust::expr_to_string(&e1);
+ let e2 = AddParens.fold_expr(RemoveParens.fold_expr(parsed));
+ let text2 = pprust::expr_to_string(&e2);
+ assert!(text1 == text2,
+ "exprs are not equal:\n e = {:?}\n parsed = {:?}",
+ text1, text2);
+ });
+}
projects / rust.git / commitdiff