pprust: fix parenthesization of exprs
This commit is contained in:
Stuart Pernsteiner
parent
f83d20eff7
commit
b79dada453
4 changed files with 417 additions and 101 deletions
227
src/test/run-pass-fulldeps/pprust-expr-roundtrip.rs
Normal file
227
src/test/run-pass-fulldeps/pprust-expr-roundtrip.rs
Normal file
|
|
@ -0,0 +1,227 @@
|
|||
// 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);
|
||||
});
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue