Update test suite to nightly-2019-02-07
diff --git a/tests/test_precedence.rs b/tests/test_precedence.rs
index 12b6a44..71017b6 100644
--- a/tests/test_precedence.rs
+++ b/tests/test_precedence.rs
@@ -211,80 +211,89 @@
/// form of the resulting expression.
///
/// This method operates on libsyntax objects.
-fn libsyntax_brackets(libsyntax_expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
+fn libsyntax_brackets(mut libsyntax_expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
use rustc_data_structures::thin_vec::ThinVec;
use smallvec::SmallVec;
+ use std::mem;
use syntax::ast::{Expr, ExprKind, Field, Mac, Pat, Stmt, StmtKind, Ty};
- use syntax::fold::{self, Folder};
+ use syntax::mut_visit::{self, MutVisitor};
use syntax_pos::DUMMY_SP;
- struct BracketsFolder {
+ struct BracketsVisitor {
failed: bool,
};
- impl Folder for BracketsFolder {
- fn fold_expr(&mut self, e: P<Expr>) -> P<Expr> {
- e.map(|e| match e.node {
- ExprKind::If(..) | ExprKind::Block(..) | ExprKind::IfLet(..) => {
- fold::noop_fold_expr(e, self)
+ impl MutVisitor for BracketsVisitor {
+ fn visit_expr(&mut self, e: &mut P<Expr>) {
+ mut_visit::noop_visit_expr(e, self);
+ match e.node {
+ ExprKind::If(..) | ExprKind::Block(..) | ExprKind::IfLet(..) => {}
+ _ => {
+ let inner = mem::replace(
+ e,
+ P(Expr {
+ id: ast::DUMMY_NODE_ID,
+ node: ExprKind::Err,
+ span: DUMMY_SP,
+ attrs: ThinVec::new(),
+ }),
+ );
+ e.node = ExprKind::Paren(inner);
}
- _ => Expr {
- id: ast::DUMMY_NODE_ID,
- node: ExprKind::Paren(P(fold::noop_fold_expr(e, self))),
- span: DUMMY_SP,
- attrs: ThinVec::new(),
- },
- })
+ }
}
- fn fold_field(&mut self, f: Field) -> Field {
- Field {
- expr: if f.is_shorthand {
- f.expr.map(|e| fold::noop_fold_expr(e, self))
- } else {
- self.fold_expr(f.expr)
- },
- ..f
+ fn visit_field(&mut self, f: &mut Field) {
+ if f.is_shorthand {
+ mut_visit::noop_visit_expr(&mut f.expr, self);
+ } else {
+ self.visit_expr(&mut f.expr);
}
}
// We don't want to look at expressions that might appear in patterns or
// types yet. We'll look into comparing those in the future. For now
// focus on expressions appearing in other places.
- fn fold_pat(&mut self, pat: P<Pat>) -> P<Pat> {
- pat
+ fn visit_pat(&mut self, pat: &mut P<Pat>) {
+ let _ = pat;
}
- fn fold_ty(&mut self, ty: P<Ty>) -> P<Ty> {
- ty
+ fn visit_ty(&mut self, ty: &mut P<Ty>) {
+ let _ = ty;
}
- fn fold_stmt(&mut self, stmt: Stmt) -> SmallVec<[Stmt; 1]> {
+ fn flat_map_stmt(&mut self, stmt: Stmt) -> SmallVec<[Stmt; 1]> {
let node = match stmt.node {
// Don't wrap toplevel expressions in statements.
- StmtKind::Expr(e) => StmtKind::Expr(e.map(|e| fold::noop_fold_expr(e, self))),
- StmtKind::Semi(e) => StmtKind::Semi(e.map(|e| fold::noop_fold_expr(e, self))),
+ StmtKind::Expr(mut e) => {
+ mut_visit::noop_visit_expr(&mut e, self);
+ StmtKind::Expr(e)
+ }
+ StmtKind::Semi(mut e) => {
+ mut_visit::noop_visit_expr(&mut e, self);
+ StmtKind::Semi(e)
+ }
s => s,
};
smallvec![Stmt { node, ..stmt }]
}
- fn fold_mac(&mut self, mac: Mac) -> Mac {
+ fn visit_mac(&mut self, mac: &mut Mac) {
// By default when folding over macros, libsyntax panics. This is
// because it's usually not what you want, you want to run after
// macro expansion. We do want to do that (syn doesn't do macro
- // expansion), so we implement fold_mac to just return the macro
+ // expansion), so we implement visit_mac to just return the macro
// unchanged.
- mac
+ let _ = mac;
}
}
- let mut folder = BracketsFolder { failed: false };
- let e = folder.fold_expr(libsyntax_expr);
+ let mut folder = BracketsVisitor { failed: false };
+ folder.visit_expr(&mut libsyntax_expr);
if folder.failed {
None
} else {
- Some(e)
+ Some(libsyntax_expr)
}
}