bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

[breaking-change] don't glob export ast::Expr_ variants

Browse source
This commit is contained in:
Oliver Schneider 2016-02-08 16:05:05 +01:00
parent 1c4d437158
commit 80bf9ae18a
29 changed files with 420 additions and 428 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc_driver/pretty.rs
View file

@ -653,7 +653,7 @@ impl fold::Folder for ReplaceBodyWithLoop {
let empty_block = expr_to_block(BlockCheckMode::Default, None); let empty_block = expr_to_block(BlockCheckMode::Default, None);
let loop_expr = P(ast::Expr { let loop_expr = P(ast::Expr {
node: ast::ExprLoop(empty_block, None), node: ast::ExprKind::Loop(empty_block, None),
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
span: codemap::DUMMY_SP, span: codemap::DUMMY_SP,
attrs: None, attrs: None,

74
src/librustc_front/lowering.rs
View file

@ -986,12 +986,12 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
// } // }
// //
// But for now there are type-inference issues doing that. // But for now there are type-inference issues doing that.
ExprBox(ref e) => { ExprKind::Box(ref e) => {
hir::ExprBox(lower_expr(lctx, e)) hir::ExprBox(lower_expr(lctx, e))
} }
// Desugar ExprBox: `in (PLACE) EXPR` // Desugar ExprBox: `in (PLACE) EXPR`
ExprInPlace(ref placer, ref value_expr) => { ExprKind::InPlace(ref placer, ref value_expr) => {
// to: // to:
// //
// let p = PLACE; // let p = PLACE;
@ -1099,57 +1099,57 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
}); });
} }
ExprVec(ref exprs) => { ExprKind::Vec(ref exprs) => {
hir::ExprVec(exprs.iter().map(|x| lower_expr(lctx, x)).collect()) hir::ExprVec(exprs.iter().map(|x| lower_expr(lctx, x)).collect())
} }
ExprRepeat(ref expr, ref count) => { ExprKind::Repeat(ref expr, ref count) => {
let expr = lower_expr(lctx, expr); let expr = lower_expr(lctx, expr);
let count = lower_expr(lctx, count); let count = lower_expr(lctx, count);
hir::ExprRepeat(expr, count) hir::ExprRepeat(expr, count)
} }
ExprTup(ref elts) => { ExprKind::Tup(ref elts) => {
hir::ExprTup(elts.iter().map(|x| lower_expr(lctx, x)).collect()) hir::ExprTup(elts.iter().map(|x| lower_expr(lctx, x)).collect())
} }
ExprCall(ref f, ref args) => { ExprKind::Call(ref f, ref args) => {
let f = lower_expr(lctx, f); let f = lower_expr(lctx, f);
hir::ExprCall(f, args.iter().map(|x| lower_expr(lctx, x)).collect()) hir::ExprCall(f, args.iter().map(|x| lower_expr(lctx, x)).collect())
} }
ExprMethodCall(i, ref tps, ref args) => { ExprKind::MethodCall(i, ref tps, ref args) => {
let tps = tps.iter().map(|x| lower_ty(lctx, x)).collect(); let tps = tps.iter().map(|x| lower_ty(lctx, x)).collect();
let args = args.iter().map(|x| lower_expr(lctx, x)).collect(); let args = args.iter().map(|x| lower_expr(lctx, x)).collect();
hir::ExprMethodCall(respan(i.span, i.node.name), tps, args) hir::ExprMethodCall(respan(i.span, i.node.name), tps, args)
} }
ExprBinary(binop, ref lhs, ref rhs) => { ExprKind::Binary(binop, ref lhs, ref rhs) => {
let binop = lower_binop(lctx, binop); let binop = lower_binop(lctx, binop);
let lhs = lower_expr(lctx, lhs); let lhs = lower_expr(lctx, lhs);
let rhs = lower_expr(lctx, rhs); let rhs = lower_expr(lctx, rhs);
hir::ExprBinary(binop, lhs, rhs) hir::ExprBinary(binop, lhs, rhs)
} }
ExprUnary(op, ref ohs) => { ExprKind::Unary(op, ref ohs) => {
let op = lower_unop(lctx, op); let op = lower_unop(lctx, op);
let ohs = lower_expr(lctx, ohs); let ohs = lower_expr(lctx, ohs);
hir::ExprUnary(op, ohs) hir::ExprUnary(op, ohs)
} }
ExprLit(ref l) => hir::ExprLit(P((**l).clone())), ExprKind::Lit(ref l) => hir::ExprLit(P((**l).clone())),
ExprCast(ref expr, ref ty) => { ExprKind::Cast(ref expr, ref ty) => {
let expr = lower_expr(lctx, expr); let expr = lower_expr(lctx, expr);
hir::ExprCast(expr, lower_ty(lctx, ty)) hir::ExprCast(expr, lower_ty(lctx, ty))
} }
ExprType(ref expr, ref ty) => { ExprKind::Type(ref expr, ref ty) => {
let expr = lower_expr(lctx, expr); let expr = lower_expr(lctx, expr);
hir::ExprType(expr, lower_ty(lctx, ty)) hir::ExprType(expr, lower_ty(lctx, ty))
} }
ExprAddrOf(m, ref ohs) => { ExprKind::AddrOf(m, ref ohs) => {
let m = lower_mutability(lctx, m); let m = lower_mutability(lctx, m);
let ohs = lower_expr(lctx, ohs); let ohs = lower_expr(lctx, ohs);
hir::ExprAddrOf(m, ohs) hir::ExprAddrOf(m, ohs)
} }
// More complicated than you might expect because the else branch // More complicated than you might expect because the else branch
// might be `if let`. // might be `if let`.
ExprIf(ref cond, ref blk, ref else_opt) => { ExprKind::If(ref cond, ref blk, ref else_opt) => {
let else_opt = else_opt.as_ref().map(|els| { let else_opt = else_opt.as_ref().map(|els| {
match els.node { match els.node {
ExprIfLet(..) => { ExprKind::IfLet(..) => {
cache_ids(lctx, e.id, |lctx| { cache_ids(lctx, e.id, |lctx| {
// wrap the if-let expr in a block // wrap the if-let expr in a block
let span = els.span; let span = els.span;
@ -1171,47 +1171,47 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
hir::ExprIf(lower_expr(lctx, cond), lower_block(lctx, blk), else_opt) hir::ExprIf(lower_expr(lctx, cond), lower_block(lctx, blk), else_opt)
} }
ExprWhile(ref cond, ref body, opt_ident) => { ExprKind::While(ref cond, ref body, opt_ident) => {
hir::ExprWhile(lower_expr(lctx, cond), lower_block(lctx, body), hir::ExprWhile(lower_expr(lctx, cond), lower_block(lctx, body),
opt_ident.map(|ident| lower_ident(lctx, ident))) opt_ident.map(|ident| lower_ident(lctx, ident)))
} }
ExprLoop(ref body, opt_ident) => { ExprKind::Loop(ref body, opt_ident) => {
hir::ExprLoop(lower_block(lctx, body), hir::ExprLoop(lower_block(lctx, body),
opt_ident.map(|ident| lower_ident(lctx, ident))) opt_ident.map(|ident| lower_ident(lctx, ident)))
} }
ExprMatch(ref expr, ref arms) => { ExprKind::Match(ref expr, ref arms) => {
hir::ExprMatch(lower_expr(lctx, expr), hir::ExprMatch(lower_expr(lctx, expr),
arms.iter().map(|x| lower_arm(lctx, x)).collect(), arms.iter().map(|x| lower_arm(lctx, x)).collect(),
hir::MatchSource::Normal) hir::MatchSource::Normal)
} }
ExprClosure(capture_clause, ref decl, ref body) => { ExprKind::Closure(capture_clause, ref decl, ref body) => {
hir::ExprClosure(lower_capture_clause(lctx, capture_clause), hir::ExprClosure(lower_capture_clause(lctx, capture_clause),
lower_fn_decl(lctx, decl), lower_fn_decl(lctx, decl),
lower_block(lctx, body)) lower_block(lctx, body))
} }
ExprBlock(ref blk) => hir::ExprBlock(lower_block(lctx, blk)), ExprKind::Block(ref blk) => hir::ExprBlock(lower_block(lctx, blk)),
ExprAssign(ref el, ref er) => { ExprKind::Assign(ref el, ref er) => {
hir::ExprAssign(lower_expr(lctx, el), lower_expr(lctx, er)) hir::ExprAssign(lower_expr(lctx, el), lower_expr(lctx, er))
} }
ExprAssignOp(op, ref el, ref er) => { ExprKind::AssignOp(op, ref el, ref er) => {
hir::ExprAssignOp(lower_binop(lctx, op), hir::ExprAssignOp(lower_binop(lctx, op),
lower_expr(lctx, el), lower_expr(lctx, el),
lower_expr(lctx, er)) lower_expr(lctx, er))
} }
ExprField(ref el, ident) => { ExprKind::Field(ref el, ident) => {
hir::ExprField(lower_expr(lctx, el), respan(ident.span, ident.node.name)) hir::ExprField(lower_expr(lctx, el), respan(ident.span, ident.node.name))
} }
ExprTupField(ref el, ident) => { ExprKind::TupField(ref el, ident) => {
hir::ExprTupField(lower_expr(lctx, el), ident) hir::ExprTupField(lower_expr(lctx, el), ident)
} }
ExprIndex(ref el, ref er) => { ExprKind::Index(ref el, ref er) => {
hir::ExprIndex(lower_expr(lctx, el), lower_expr(lctx, er)) hir::ExprIndex(lower_expr(lctx, el), lower_expr(lctx, er))
} }
ExprRange(ref e1, ref e2) => { ExprKind::Range(ref e1, ref e2) => {
hir::ExprRange(e1.as_ref().map(|x| lower_expr(lctx, x)), hir::ExprRange(e1.as_ref().map(|x| lower_expr(lctx, x)),
e2.as_ref().map(|x| lower_expr(lctx, x))) e2.as_ref().map(|x| lower_expr(lctx, x)))
} }
ExprPath(ref qself, ref path) => { ExprKind::Path(ref qself, ref path) => {
let hir_qself = qself.as_ref().map(|&QSelf { ref ty, position }| { let hir_qself = qself.as_ref().map(|&QSelf { ref ty, position }| {
hir::QSelf { hir::QSelf {
ty: lower_ty(lctx, ty), ty: lower_ty(lctx, ty),
@ -1220,14 +1220,14 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
}); });
hir::ExprPath(hir_qself, lower_path_full(lctx, path, qself.is_none())) hir::ExprPath(hir_qself, lower_path_full(lctx, path, qself.is_none()))
} }
ExprBreak(opt_ident) => hir::ExprBreak(opt_ident.map(|sp_ident| { ExprKind::Break(opt_ident) => hir::ExprBreak(opt_ident.map(|sp_ident| {
respan(sp_ident.span, lower_ident(lctx, sp_ident.node)) respan(sp_ident.span, lower_ident(lctx, sp_ident.node))
})), })),
ExprAgain(opt_ident) => hir::ExprAgain(opt_ident.map(|sp_ident| { ExprKind::Again(opt_ident) => hir::ExprAgain(opt_ident.map(|sp_ident| {
respan(sp_ident.span, lower_ident(lctx, sp_ident.node)) respan(sp_ident.span, lower_ident(lctx, sp_ident.node))
})), })),
ExprRet(ref e) => hir::ExprRet(e.as_ref().map(|x| lower_expr(lctx, x))), ExprKind::Ret(ref e) => hir::ExprRet(e.as_ref().map(|x| lower_expr(lctx, x))),
ExprInlineAsm(InlineAsm { ExprKind::InlineAsm(InlineAsm {
ref inputs, ref inputs,
ref outputs, ref outputs,
ref asm, ref asm,
@ -1259,12 +1259,12 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
dialect: dialect, dialect: dialect,
expn_id: expn_id, expn_id: expn_id,
}), }),
ExprStruct(ref path, ref fields, ref maybe_expr) => { ExprKind::Struct(ref path, ref fields, ref maybe_expr) => {
hir::ExprStruct(lower_path(lctx, path), hir::ExprStruct(lower_path(lctx, path),
fields.iter().map(|x| lower_field(lctx, x)).collect(), fields.iter().map(|x| lower_field(lctx, x)).collect(),
maybe_expr.as_ref().map(|x| lower_expr(lctx, x))) maybe_expr.as_ref().map(|x| lower_expr(lctx, x)))
} }
ExprParen(ref ex) => { ExprKind::Paren(ref ex) => {
// merge attributes into the inner expression. // merge attributes into the inner expression.
return lower_expr(lctx, ex).map(|mut ex| { return lower_expr(lctx, ex).map(|mut ex| {
ex.attrs.update(|attrs| { ex.attrs.update(|attrs| {
@ -1276,7 +1276,7 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
// Desugar ExprIfLet // Desugar ExprIfLet
// From: `if let <pat> = <sub_expr> <body> [<else_opt>]` // From: `if let <pat> = <sub_expr> <body> [<else_opt>]`
ExprIfLet(ref pat, ref sub_expr, ref body, ref else_opt) => { ExprKind::IfLet(ref pat, ref sub_expr, ref body, ref else_opt) => {
// to: // to:
// //
// match <sub_expr> { // match <sub_expr> {
@ -1364,7 +1364,7 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
// Desugar ExprWhileLet // Desugar ExprWhileLet
// From: `[opt_ident]: while let <pat> = <sub_expr> <body>` // From: `[opt_ident]: while let <pat> = <sub_expr> <body>`
ExprWhileLet(ref pat, ref sub_expr, ref body, opt_ident) => { ExprKind::WhileLet(ref pat, ref sub_expr, ref body, opt_ident) => {
// to: // to:
// //
// [opt_ident]: loop { // [opt_ident]: loop {
@ -1410,7 +1410,7 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
// Desugar ExprForLoop // Desugar ExprForLoop
// From: `[opt_ident]: for <pat> in <head> <body>` // From: `[opt_ident]: for <pat> in <head> <body>`
ExprForLoop(ref pat, ref head, ref body, opt_ident) => { ExprKind::ForLoop(ref pat, ref head, ref body, opt_ident) => {
// to: // to:
// //
// { // {
@ -1524,7 +1524,7 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
}); });
} }
ExprMac(_) => panic!("Shouldn't exist here"), ExprKind::Mac(_) => panic!("Shouldn't exist here"),
}, },
span: e.span, span: e.span,
attrs: e.attrs.clone(), attrs: e.attrs.clone(),

45
src/librustc_lint/unused.rs
View file

@ -293,7 +293,7 @@ pub struct UnusedParens;
impl UnusedParens { impl UnusedParens {
fn check_unused_parens_core(&self, cx: &EarlyContext, value: &ast::Expr, msg: &str, fn check_unused_parens_core(&self, cx: &EarlyContext, value: &ast::Expr, msg: &str,
struct_lit_needs_parens: bool) { struct_lit_needs_parens: bool) {
if let ast::ExprParen(ref inner) = value.node { 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 && contains_exterior_struct_lit(&**inner);
if !necessary { if !necessary {
cx.span_lint(UNUSED_PARENS, value.span, cx.span_lint(UNUSED_PARENS, value.span,
@ -308,26 +308,26 @@ impl UnusedParens {
/// y: 1 }) == foo` does not. /// y: 1 }) == foo` does not.
fn contains_exterior_struct_lit(value: &ast::Expr) -> bool { fn contains_exterior_struct_lit(value: &ast::Expr) -> bool {
match value.node { match value.node {
ast::ExprStruct(..) => true, ast::ExprKind::Struct(..) => true,
ast::ExprAssign(ref lhs, ref rhs) | ast::ExprKind::Assign(ref lhs, ref rhs) |
ast::ExprAssignOp(_, ref lhs, ref rhs) | ast::ExprKind::AssignOp(_, ref lhs, ref rhs) |
ast::ExprBinary(_, ref lhs, ref rhs) => { ast::ExprKind::Binary(_, ref lhs, ref rhs) => {
// X { y: 1 } + X { y: 2 } // X { y: 1 } + X { y: 2 }
contains_exterior_struct_lit(&**lhs) || contains_exterior_struct_lit(&**lhs) ||
contains_exterior_struct_lit(&**rhs) contains_exterior_struct_lit(&**rhs)
} }
ast::ExprUnary(_, ref x) | ast::ExprKind::Unary(_, ref x) |
ast::ExprCast(ref x, _) | ast::ExprKind::Cast(ref x, _) |
ast::ExprType(ref x, _) | ast::ExprKind::Type(ref x, _) |
ast::ExprField(ref x, _) | ast::ExprKind::Field(ref x, _) |
ast::ExprTupField(ref x, _) | ast::ExprKind::TupField(ref x, _) |
ast::ExprIndex(ref x, _) => { ast::ExprKind::Index(ref x, _) => {
// &X { y: 1 }, X { y: 1 }.y // &X { y: 1 }, X { y: 1 }.y
contains_exterior_struct_lit(&**x) contains_exterior_struct_lit(&**x)
} }
ast::ExprMethodCall(_, _, ref exprs) => { ast::ExprKind::MethodCall(_, _, ref exprs) => {
// X { y: 1 }.bar(...) // X { y: 1 }.bar(...)
contains_exterior_struct_lit(&*exprs[0]) contains_exterior_struct_lit(&*exprs[0])
} }
@ -346,17 +346,18 @@ impl LintPass for UnusedParens {
impl EarlyLintPass for UnusedParens { impl EarlyLintPass for UnusedParens {
fn check_expr(&mut self, cx: &EarlyContext, e: &ast::Expr) { fn check_expr(&mut self, cx: &EarlyContext, e: &ast::Expr) {
use syntax::ast::ExprKind::*;
let (value, msg, struct_lit_needs_parens) = match e.node { let (value, msg, struct_lit_needs_parens) = match e.node {
ast::ExprIf(ref cond, _, _) => (cond, "`if` condition", true), If(ref cond, _, _) => (cond, "`if` condition", true),
ast::ExprWhile(ref cond, _, _) => (cond, "`while` condition", true), While(ref cond, _, _) => (cond, "`while` condition", true),
ast::ExprIfLet(_, ref cond, _, _) => (cond, "`if let` head expression", true), IfLet(_, ref cond, _, _) => (cond, "`if let` head expression", true),
ast::ExprWhileLet(_, ref cond, _, _) => (cond, "`while let` head expression", true), WhileLet(_, ref cond, _, _) => (cond, "`while let` head expression", true),
ast::ExprForLoop(_, ref cond, _, _) => (cond, "`for` head expression", true), ForLoop(_, ref cond, _, _) => (cond, "`for` head expression", true),
ast::ExprMatch(ref head, _) => (head, "`match` head expression", true), Match(ref head, _) => (head, "`match` head expression", true),
ast::ExprRet(Some(ref value)) => (value, "`return` value", false), Ret(Some(ref value)) => (value, "`return` value", false),
ast::ExprAssign(_, ref value) => (value, "assigned value", false), Assign(_, ref value) => (value, "assigned value", false),
ast::ExprAssignOp(_, _, ref value) => (value, "assigned value", false), AssignOp(_, _, ref value) => (value, "assigned value", false),
ast::ExprInPlace(_, ref value) => (value, "emplacement value", false), InPlace(_, ref value) => (value, "emplacement value", false),
_ => return _ => return
}; };
self.check_unused_parens_core(cx, &**value, msg, struct_lit_needs_parens); self.check_unused_parens_core(cx, &**value, msg, struct_lit_needs_parens);

2
src/librustc_passes/const_fn.rs
View file

@ -38,7 +38,7 @@ impl<'a, 'v> Visitor<'v> for CheckBlock<'a> {
CheckConstFn{ sess: self.sess}.visit_block(block); CheckConstFn{ sess: self.sess}.visit_block(block);
} }
fn visit_expr(&mut self, e: &'v ast::Expr) { fn visit_expr(&mut self, e: &'v ast::Expr) {
if let ast::ExprClosure(..) = e.node { if let ast::ExprKind::Closure(..) = e.node {
CheckConstFn{ sess: self.sess}.visit_expr(e); CheckConstFn{ sess: self.sess}.visit_expr(e);
} else { } else {
visit::walk_expr(self, e); visit::walk_expr(self, e);

2
src/librustc_passes/no_asm.rs
View file

@ -32,7 +32,7 @@ struct CheckNoAsm<'a> {
impl<'a, 'v> Visitor<'v> for CheckNoAsm<'a> { impl<'a, 'v> Visitor<'v> for CheckNoAsm<'a> {
fn visit_expr(&mut self, e: &ast::Expr) { fn visit_expr(&mut self, e: &ast::Expr) {
match e.node { match e.node {
ast::ExprInlineAsm(_) => span_err!(self.sess, e.span, E0472, ast::ExprKind::InlineAsm(_) => span_err!(self.sess, e.span, E0472,
"asm! is unsupported on this target"), "asm! is unsupported on this target"),
_ => {}, _ => {},
} }

20
src/librustc_trans/save/dump_csv.rs
View file

@ -1083,23 +1083,23 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
fn visit_expr(&mut self, ex: &ast::Expr) { fn visit_expr(&mut self, ex: &ast::Expr) {
self.process_macro_use(ex.span, ex.id); self.process_macro_use(ex.span, ex.id);
match ex.node { match ex.node {
ast::ExprCall(ref _f, ref _args) => { ast::ExprKind::Call(ref _f, ref _args) => {
// Don't need to do anything for function calls, // Don't need to do anything for function calls,
// because just walking the callee path does what we want. // because just walking the callee path does what we want.
visit::walk_expr(self, ex); visit::walk_expr(self, ex);
} }
ast::ExprPath(_, ref path) => { ast::ExprKind::Path(_, ref path) => {
self.process_path(ex.id, path, None); self.process_path(ex.id, path, None);
visit::walk_expr(self, ex); visit::walk_expr(self, ex);
} }
ast::ExprStruct(ref path, ref fields, ref base) => { ast::ExprKind::Struct(ref path, ref fields, ref base) => {
let hir_expr = lower_expr(self.save_ctxt.lcx, ex); let hir_expr = lower_expr(self.save_ctxt.lcx, ex);
let adt = self.tcx.expr_ty(&hir_expr).ty_adt_def().unwrap(); let adt = self.tcx.expr_ty(&hir_expr).ty_adt_def().unwrap();
let def = self.tcx.resolve_expr(&hir_expr); let def = self.tcx.resolve_expr(&hir_expr);
self.process_struct_lit(ex, path, fields, adt.variant_of_def(def), base) self.process_struct_lit(ex, path, fields, adt.variant_of_def(def), base)
} }
ast::ExprMethodCall(_, _, ref args) => self.process_method_call(ex, args), ast::ExprKind::MethodCall(_, _, ref args) => self.process_method_call(ex, args),
ast::ExprField(ref sub_ex, _) => { ast::ExprKind::Field(ref sub_ex, _) => {
self.visit_expr(&sub_ex); self.visit_expr(&sub_ex);
if let Some(field_data) = self.save_ctxt.get_expr_data(ex) { if let Some(field_data) = self.save_ctxt.get_expr_data(ex) {
@ -1111,7 +1111,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
field_data.scope); field_data.scope);
} }
} }
ast::ExprTupField(ref sub_ex, idx) => { ast::ExprKind::TupField(ref sub_ex, idx) => {
self.visit_expr(&**sub_ex); self.visit_expr(&**sub_ex);
let hir_node = lower_expr(self.save_ctxt.lcx, sub_ex); let hir_node = lower_expr(self.save_ctxt.lcx, sub_ex);
@ -1131,7 +1131,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
ty)), ty)),
} }
} }
ast::ExprClosure(_, ref decl, ref body) => { ast::ExprKind::Closure(_, ref decl, ref body) => {
let mut id = String::from("$"); let mut id = String::from("$");
id.push_str(&ex.id.to_string()); id.push_str(&ex.id.to_string());
self.process_formals(&decl.inputs, &id); self.process_formals(&decl.inputs, &id);
@ -1148,14 +1148,14 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
// walk the body // walk the body
self.nest(ex.id, |v| v.visit_block(&**body)); self.nest(ex.id, |v| v.visit_block(&**body));
} }
ast::ExprForLoop(ref pattern, ref subexpression, ref block, _) | ast::ExprKind::ForLoop(ref pattern, ref subexpression, ref block, _) |
ast::ExprWhileLet(ref pattern, ref subexpression, ref block, _) => { ast::ExprKind::WhileLet(ref pattern, ref subexpression, ref block, _) => {
let value = self.span.snippet(mk_sp(ex.span.lo, subexpression.span.hi)); let value = self.span.snippet(mk_sp(ex.span.lo, subexpression.span.hi));
self.process_var_decl(pattern, value); self.process_var_decl(pattern, value);
visit::walk_expr(self, subexpression); visit::walk_expr(self, subexpression);
visit::walk_block(self, block); visit::walk_block(self, block);
} }
ast::ExprIfLet(ref pattern, ref subexpression, ref block, ref opt_else) => { ast::ExprKind::IfLet(ref pattern, ref subexpression, ref block, ref opt_else) => {
let value = self.span.snippet(mk_sp(ex.span.lo, subexpression.span.hi)); let value = self.span.snippet(mk_sp(ex.span.lo, subexpression.span.hi));
self.process_var_decl(pattern, value); self.process_var_decl(pattern, value);
visit::walk_expr(self, subexpression); visit::walk_expr(self, subexpression);

8
src/librustc_trans/save/mod.rs
View file

@ -487,7 +487,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
return None; return None;
} }
match expr.node { match expr.node {
ast::ExprField(ref sub_ex, ident) => { ast::ExprKind::Field(ref sub_ex, ident) => {
let hir_node = lowering::lower_expr(self.lcx, sub_ex); let hir_node = lowering::lower_expr(self.lcx, sub_ex);
match self.tcx.expr_ty_adjusted(&hir_node).sty { match self.tcx.expr_ty_adjusted(&hir_node).sty {
ty::TyStruct(def, _) => { ty::TyStruct(def, _) => {
@ -507,7 +507,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
} }
} }
} }
ast::ExprStruct(ref path, _, _) => { ast::ExprKind::Struct(ref path, _, _) => {
let hir_node = lowering::lower_expr(self.lcx, expr); let hir_node = lowering::lower_expr(self.lcx, expr);
match self.tcx.expr_ty_adjusted(&hir_node).sty { match self.tcx.expr_ty_adjusted(&hir_node).sty {
ty::TyStruct(def, _) => { ty::TyStruct(def, _) => {
@ -527,7 +527,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
} }
} }
} }
ast::ExprMethodCall(..) => { ast::ExprKind::MethodCall(..) => {
let method_call = ty::MethodCall::expr(expr.id); let method_call = ty::MethodCall::expr(expr.id);
let method_id = self.tcx.tables.borrow().method_map[&method_call].def_id; let method_id = self.tcx.tables.borrow().method_map[&method_call].def_id;
let (def_id, decl_id) = match self.tcx.impl_or_trait_item(method_id).container() { let (def_id, decl_id) = match self.tcx.impl_or_trait_item(method_id).container() {
@ -544,7 +544,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
decl_id: decl_id, decl_id: decl_id,
})) }))
} }
ast::ExprPath(_, ref path) => { ast::ExprKind::Path(_, ref path) => {
self.get_path_data(expr.id, path) self.get_path_data(expr.id, path)
} }
_ => { _ => {

79
src/libsyntax/ast.rs
View file

@ -10,7 +10,6 @@
// The Rust abstract syntax tree. // The Rust abstract syntax tree.
pub use self::Expr_::*;
pub use self::FloatTy::*; pub use self::FloatTy::*;
pub use self::ForeignItem_::*; pub use self::ForeignItem_::*;
pub use self::IntTy::*; pub use self::IntTy::*;
@ -880,7 +879,7 @@ pub enum UnsafeSource {
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash,)] #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash,)]
pub struct Expr { pub struct Expr {
pub id: NodeId, pub id: NodeId,
pub node: Expr_, pub node: ExprKind,
pub span: Span, pub span: Span,
pub attrs: ThinAttributes pub attrs: ThinAttributes
} }
@ -901,18 +900,18 @@ impl fmt::Debug for Expr {
} }
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum Expr_ { pub enum ExprKind {
/// A `box x` expression. /// A `box x` expression.
ExprBox(P<Expr>), Box(P<Expr>),
/// First expr is the place; second expr is the value. /// First expr is the place; second expr is the value.
ExprInPlace(P<Expr>, P<Expr>), InPlace(P<Expr>, P<Expr>),
/// An array (`[a, b, c, d]`) /// An array (`[a, b, c, d]`)
ExprVec(Vec<P<Expr>>), Vec(Vec<P<Expr>>),
/// A function call /// A function call
/// ///
/// The first field resolves to the function itself, /// The first field resolves to the function itself,
/// and the second field is the list of arguments /// and the second field is the list of arguments
ExprCall(P<Expr>, Vec<P<Expr>>), Call(P<Expr>, Vec<P<Expr>>),
/// A method call (`x.foo::<Bar, Baz>(a, b, c, d)`) /// A method call (`x.foo::<Bar, Baz>(a, b, c, d)`)
/// ///
/// The `SpannedIdent` is the identifier for the method name. /// The `SpannedIdent` is the identifier for the method name.
@ -924,109 +923,109 @@ pub enum Expr_ {
/// and the remaining elements are the rest of the arguments. /// and the remaining elements are the rest of the arguments.
/// ///
/// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as /// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as
/// `ExprMethodCall(foo, [Bar, Baz], [x, a, b, c, d])`. /// `ExprKind::MethodCall(foo, [Bar, Baz], [x, a, b, c, d])`.
ExprMethodCall(SpannedIdent, Vec<P<Ty>>, Vec<P<Expr>>), MethodCall(SpannedIdent, Vec<P<Ty>>, Vec<P<Expr>>),
/// A tuple (`(a, b, c ,d)`) /// A tuple (`(a, b, c ,d)`)
ExprTup(Vec<P<Expr>>), Tup(Vec<P<Expr>>),
/// A binary operation (For example: `a + b`, `a * b`) /// A binary operation (For example: `a + b`, `a * b`)
ExprBinary(BinOp, P<Expr>, P<Expr>), Binary(BinOp, P<Expr>, P<Expr>),
/// A unary operation (For example: `!x`, `*x`) /// A unary operation (For example: `!x`, `*x`)
ExprUnary(UnOp, P<Expr>), Unary(UnOp, P<Expr>),
/// A literal (For example: `1u8`, `"foo"`) /// A literal (For example: `1u8`, `"foo"`)
ExprLit(P<Lit>), Lit(P<Lit>),
/// A cast (`foo as f64`) /// A cast (`foo as f64`)
ExprCast(P<Expr>, P<Ty>), Cast(P<Expr>, P<Ty>),
ExprType(P<Expr>, P<Ty>), Type(P<Expr>, P<Ty>),
/// An `if` block, with an optional else block /// An `if` block, with an optional else block
/// ///
/// `if expr { block } else { expr }` /// `if expr { block } else { expr }`
ExprIf(P<Expr>, P<Block>, Option<P<Expr>>), If(P<Expr>, P<Block>, Option<P<Expr>>),
/// An `if let` expression with an optional else block /// An `if let` expression with an optional else block
/// ///
/// `if let pat = expr { block } else { expr }` /// `if let pat = expr { block } else { expr }`
/// ///
/// This is desugared to a `match` expression. /// This is desugared to a `match` expression.
ExprIfLet(P<Pat>, P<Expr>, P<Block>, Option<P<Expr>>), IfLet(P<Pat>, P<Expr>, P<Block>, Option<P<Expr>>),
/// A while loop, with an optional label /// A while loop, with an optional label
/// ///
/// `'label: while expr { block }` /// `'label: while expr { block }`
ExprWhile(P<Expr>, P<Block>, Option<Ident>), While(P<Expr>, P<Block>, Option<Ident>),
/// A while-let loop, with an optional label /// A while-let loop, with an optional label
/// ///
/// `'label: while let pat = expr { block }` /// `'label: while let pat = expr { block }`
/// ///
/// This is desugared to a combination of `loop` and `match` expressions. /// This is desugared to a combination of `loop` and `match` expressions.
ExprWhileLet(P<Pat>, P<Expr>, P<Block>, Option<Ident>), WhileLet(P<Pat>, P<Expr>, P<Block>, Option<Ident>),
/// A for loop, with an optional label /// A for loop, with an optional label
/// ///
/// `'label: for pat in expr { block }` /// `'label: for pat in expr { block }`
/// ///
/// This is desugared to a combination of `loop` and `match` expressions. /// This is desugared to a combination of `loop` and `match` expressions.
ExprForLoop(P<Pat>, P<Expr>, P<Block>, Option<Ident>), ForLoop(P<Pat>, P<Expr>, P<Block>, Option<Ident>),
/// Conditionless loop (can be exited with break, continue, or return) /// Conditionless loop (can be exited with break, continue, or return)
/// ///
/// `'label: loop { block }` /// `'label: loop { block }`
ExprLoop(P<Block>, Option<Ident>), Loop(P<Block>, Option<Ident>),
/// A `match` block. /// A `match` block.
ExprMatch(P<Expr>, Vec<Arm>), Match(P<Expr>, Vec<Arm>),
/// A closure (for example, `move |a, b, c| {a + b + c}`) /// A closure (for example, `move |a, b, c| {a + b + c}`)
ExprClosure(CaptureBy, P<FnDecl>, P<Block>), Closure(CaptureBy, P<FnDecl>, P<Block>),
/// A block (`{ ... }`) /// A block (`{ ... }`)
ExprBlock(P<Block>), Block(P<Block>),
/// An assignment (`a = foo()`) /// An assignment (`a = foo()`)
ExprAssign(P<Expr>, P<Expr>), Assign(P<Expr>, P<Expr>),
/// An assignment with an operator /// An assignment with an operator
/// ///
/// For example, `a += 1`. /// For example, `a += 1`.
ExprAssignOp(BinOp, P<Expr>, P<Expr>), AssignOp(BinOp, P<Expr>, P<Expr>),
/// Access of a named struct field (`obj.foo`) /// Access of a named struct field (`obj.foo`)
ExprField(P<Expr>, SpannedIdent), Field(P<Expr>, SpannedIdent),
/// Access of an unnamed field of a struct or tuple-struct /// Access of an unnamed field of a struct or tuple-struct
/// ///
/// For example, `foo.0`. /// For example, `foo.0`.
ExprTupField(P<Expr>, Spanned<usize>), TupField(P<Expr>, Spanned<usize>),
/// An indexing operation (`foo[2]`) /// An indexing operation (`foo[2]`)
ExprIndex(P<Expr>, P<Expr>), Index(P<Expr>, P<Expr>),
/// A range (`1..2`, `1..`, or `..2`) /// A range (`1..2`, `1..`, or `..2`)
ExprRange(Option<P<Expr>>, Option<P<Expr>>), Range(Option<P<Expr>>, Option<P<Expr>>),
/// Variable reference, possibly containing `::` and/or type /// Variable reference, possibly containing `::` and/or type
/// parameters, e.g. foo::bar::<baz>. /// parameters, e.g. foo::bar::<baz>.
/// ///
/// Optionally "qualified", /// Optionally "qualified",
/// e.g. `<Vec<T> as SomeTrait>::SomeType`. /// e.g. `<Vec<T> as SomeTrait>::SomeType`.
ExprPath(Option<QSelf>, Path), Path(Option<QSelf>, Path),
/// A referencing operation (`&a` or `&mut a`) /// A referencing operation (`&a` or `&mut a`)
ExprAddrOf(Mutability, P<Expr>), AddrOf(Mutability, P<Expr>),
/// A `break`, with an optional label to break /// A `break`, with an optional label to break
ExprBreak(Option<SpannedIdent>), Break(Option<SpannedIdent>),
/// A `continue`, with an optional label /// A `continue`, with an optional label
ExprAgain(Option<SpannedIdent>), Again(Option<SpannedIdent>),
/// A `return`, with an optional value to be returned /// A `return`, with an optional value to be returned
ExprRet(Option<P<Expr>>), Ret(Option<P<Expr>>),
/// Output of the `asm!()` macro /// Output of the `asm!()` macro
ExprInlineAsm(InlineAsm), InlineAsm(InlineAsm),
/// A macro invocation; pre-expansion /// A macro invocation; pre-expansion
ExprMac(Mac), Mac(Mac),
/// A struct literal expression. /// A struct literal expression.
/// ///
/// For example, `Foo {x: 1, y: 2}`, or /// For example, `Foo {x: 1, y: 2}`, or
/// `Foo {x: 1, .. base}`, where `base` is the `Option<Expr>`. /// `Foo {x: 1, .. base}`, where `base` is the `Option<Expr>`.
ExprStruct(Path, Vec<Field>, Option<P<Expr>>), Struct(Path, Vec<Field>, Option<P<Expr>>),
/// An array literal constructed from one repeated element. /// An array literal constructed from one repeated element.
/// ///
/// For example, `[1u8; 5]`. The first expression is the element /// For example, `[1u8; 5]`. The first expression is the element
/// to be repeated; the second is the number of times to repeat it. /// to be repeated; the second is the number of times to repeat it.
ExprRepeat(P<Expr>, P<Expr>), Repeat(P<Expr>, P<Expr>),
/// No-op: used solely so we can pretty-print faithfully /// No-op: used solely so we can pretty-print faithfully
ExprParen(P<Expr>) Paren(P<Expr>),
} }
/// The explicit Self type in a "qualified path". The actual /// The explicit Self type in a "qualified path". The actual

2
src/libsyntax/ast_util.rs
View file

@ -27,7 +27,7 @@ pub fn path_name_i(idents: &[Ident]) -> String {
} }
pub fn is_path(e: P<Expr>) -> bool { pub fn is_path(e: P<Expr>) -> bool {
match e.node { ExprPath(..) => true, _ => false } match e.node { ExprKind::Path(..) => true, _ => false }
} }

4
src/libsyntax/config.rs
View file

@ -212,8 +212,8 @@ fn fold_expr<F>(cx: &mut Context<F>, expr: P<ast::Expr>) -> P<ast::Expr> where
fold::noop_fold_expr(ast::Expr { fold::noop_fold_expr(ast::Expr {
id: id, id: id,
node: match node { node: match node {
ast::ExprMatch(m, arms) => { ast::ExprKind::Match(m, arms) => {
ast::ExprMatch(m, arms.into_iter() ast::ExprKind::Match(m, arms.into_iter()
.filter(|a| (cx.in_cfg)(&a.attrs)) .filter(|a| (cx.in_cfg)(&a.attrs))
.collect()) .collect())
} }

6
src/libsyntax/ext/base.rs
View file

@ -303,7 +303,7 @@ impl MacResult for MacEager {
return Some(p); return Some(p);
} }
if let Some(e) = self.expr { if let Some(e) = self.expr {
if let ast::ExprLit(_) = e.node { if let ast::ExprKind::Lit(_) = e.node {
return Some(P(ast::Pat { return Some(P(ast::Pat {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
span: e.span, span: e.span,
@ -349,7 +349,7 @@ impl DummyResult {
pub fn raw_expr(sp: Span) -> P<ast::Expr> { pub fn raw_expr(sp: Span) -> P<ast::Expr> {
P(ast::Expr { P(ast::Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ExprLit(P(codemap::respan(sp, ast::LitBool(false)))), node: ast::ExprKind::Lit(P(codemap::respan(sp, ast::LitBool(false)))),
span: sp, span: sp,
attrs: None, attrs: None,
}) })
@ -773,7 +773,7 @@ pub fn expr_to_string(cx: &mut ExtCtxt, expr: P<ast::Expr>, err_msg: &str)
// we want to be able to handle e.g. concat("foo", "bar") // we want to be able to handle e.g. concat("foo", "bar")
let expr = cx.expander().fold_expr(expr); let expr = cx.expander().fold_expr(expr);
match expr.node { match expr.node {
ast::ExprLit(ref l) => match l.node { ast::ExprKind::Lit(ref l) => match l.node {
ast::LitStr(ref s, style) => return Some(((*s).clone(), style)), ast::LitStr(ref s, style) => return Some(((*s).clone(), style)),
_ => cx.span_err(l.span, err_msg) _ => cx.span_err(l.span, err_msg)
}, },

52
src/libsyntax/ext/build.rs
View file

@ -108,7 +108,7 @@ pub trait AstBuilder {
expr: Option<P<ast::Expr>>) -> P<ast::Block>; expr: Option<P<ast::Expr>>) -> P<ast::Block>;
// expressions // expressions
fn expr(&self, span: Span, node: ast::Expr_) -> P<ast::Expr>; fn expr(&self, span: Span, node: ast::ExprKind) -> P<ast::Expr>;
fn expr_path(&self, path: ast::Path) -> P<ast::Expr>; fn expr_path(&self, path: ast::Path) -> P<ast::Expr>;
fn expr_qpath(&self, span: Span, qself: ast::QSelf, path: ast::Path) -> P<ast::Expr>; fn expr_qpath(&self, span: Span, qself: ast::QSelf, path: ast::Path) -> P<ast::Expr>;
fn expr_ident(&self, span: Span, id: ast::Ident) -> P<ast::Expr>; fn expr_ident(&self, span: Span, id: ast::Ident) -> P<ast::Expr>;
@ -578,7 +578,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
}) })
} }
fn expr(&self, span: Span, node: ast::Expr_) -> P<ast::Expr> { fn expr(&self, span: Span, node: ast::ExprKind) -> P<ast::Expr> {
P(ast::Expr { P(ast::Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: node, node: node,
@ -588,12 +588,12 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
} }
fn expr_path(&self, path: ast::Path) -> P<ast::Expr> { fn expr_path(&self, path: ast::Path) -> P<ast::Expr> {
self.expr(path.span, ast::ExprPath(None, path)) self.expr(path.span, ast::ExprKind::Path(None, path))
} }
/// Constructs a QPath expression. /// Constructs a QPath expression.
fn expr_qpath(&self, span: Span, qself: ast::QSelf, path: ast::Path) -> P<ast::Expr> { fn expr_qpath(&self, span: Span, qself: ast::QSelf, path: ast::Path) -> P<ast::Expr> {
self.expr(span, ast::ExprPath(Some(qself), path)) self.expr(span, ast::ExprKind::Path(Some(qself), path))
} }
fn expr_ident(&self, span: Span, id: ast::Ident) -> P<ast::Expr> { fn expr_ident(&self, span: Span, id: ast::Ident) -> P<ast::Expr> {
@ -605,14 +605,14 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn expr_binary(&self, sp: Span, op: ast::BinOpKind, fn expr_binary(&self, sp: Span, op: ast::BinOpKind,
lhs: P<ast::Expr>, rhs: P<ast::Expr>) -> P<ast::Expr> { lhs: P<ast::Expr>, rhs: P<ast::Expr>) -> P<ast::Expr> {
self.expr(sp, ast::ExprBinary(Spanned { node: op, span: sp }, lhs, rhs)) self.expr(sp, ast::ExprKind::Binary(Spanned { node: op, span: sp }, lhs, rhs))
} }
fn expr_deref(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> { fn expr_deref(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> {
self.expr_unary(sp, UnOp::Deref, e) self.expr_unary(sp, UnOp::Deref, e)
} }
fn expr_unary(&self, sp: Span, op: ast::UnOp, e: P<ast::Expr>) -> P<ast::Expr> { fn expr_unary(&self, sp: Span, op: ast::UnOp, e: P<ast::Expr>) -> P<ast::Expr> {
self.expr(sp, ast::ExprUnary(op, e)) self.expr(sp, ast::ExprKind::Unary(op, e))
} }
fn expr_field_access(&self, sp: Span, expr: P<ast::Expr>, ident: ast::Ident) -> P<ast::Expr> { fn expr_field_access(&self, sp: Span, expr: P<ast::Expr>, ident: ast::Ident) -> P<ast::Expr> {
@ -623,7 +623,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
}; };
let id = Spanned { node: ident, span: field_span }; let id = Spanned { node: ident, span: field_span };
self.expr(sp, ast::ExprField(expr, id)) self.expr(sp, ast::ExprKind::Field(expr, id))
} }
fn expr_tup_field_access(&self, sp: Span, expr: P<ast::Expr>, idx: usize) -> P<ast::Expr> { fn expr_tup_field_access(&self, sp: Span, expr: P<ast::Expr>, idx: usize) -> P<ast::Expr> {
let field_span = Span { let field_span = Span {
@ -633,21 +633,21 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
}; };
let id = Spanned { node: idx, span: field_span }; let id = Spanned { node: idx, span: field_span };
self.expr(sp, ast::ExprTupField(expr, id)) self.expr(sp, ast::ExprKind::TupField(expr, id))
} }
fn expr_addr_of(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> { fn expr_addr_of(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> {
self.expr(sp, ast::ExprAddrOf(ast::MutImmutable, e)) self.expr(sp, ast::ExprKind::AddrOf(ast::MutImmutable, e))
} }
fn expr_mut_addr_of(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> { fn expr_mut_addr_of(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> {
self.expr(sp, ast::ExprAddrOf(ast::MutMutable, e)) self.expr(sp, ast::ExprKind::AddrOf(ast::MutMutable, e))
} }
fn expr_call(&self, span: Span, expr: P<ast::Expr>, args: Vec<P<ast::Expr>>) -> P<ast::Expr> { fn expr_call(&self, span: Span, expr: P<ast::Expr>, args: Vec<P<ast::Expr>>) -> P<ast::Expr> {
self.expr(span, ast::ExprCall(expr, args)) self.expr(span, ast::ExprKind::Call(expr, args))
} }
fn expr_call_ident(&self, span: Span, id: ast::Ident, fn expr_call_ident(&self, span: Span, id: ast::Ident,
args: Vec<P<ast::Expr>>) -> P<ast::Expr> { args: Vec<P<ast::Expr>>) -> P<ast::Expr> {
self.expr(span, ast::ExprCall(self.expr_ident(span, id), args)) self.expr(span, ast::ExprKind::Call(self.expr_ident(span, id), args))
} }
fn expr_call_global(&self, sp: Span, fn_path: Vec<ast::Ident> , fn expr_call_global(&self, sp: Span, fn_path: Vec<ast::Ident> ,
args: Vec<P<ast::Expr>> ) -> P<ast::Expr> { args: Vec<P<ast::Expr>> ) -> P<ast::Expr> {
@ -660,16 +660,16 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
mut args: Vec<P<ast::Expr>> ) -> P<ast::Expr> { mut args: Vec<P<ast::Expr>> ) -> P<ast::Expr> {
let id = Spanned { node: ident, span: span }; let id = Spanned { node: ident, span: span };
args.insert(0, expr); args.insert(0, expr);
self.expr(span, ast::ExprMethodCall(id, Vec::new(), args)) self.expr(span, ast::ExprKind::MethodCall(id, Vec::new(), args))
} }
fn expr_block(&self, b: P<ast::Block>) -> P<ast::Expr> { fn expr_block(&self, b: P<ast::Block>) -> P<ast::Expr> {
self.expr(b.span, ast::ExprBlock(b)) self.expr(b.span, ast::ExprKind::Block(b))
} }
fn field_imm(&self, span: Span, name: Ident, e: P<ast::Expr>) -> ast::Field { fn field_imm(&self, span: Span, name: Ident, e: P<ast::Expr>) -> ast::Field {
ast::Field { ident: respan(span, name), expr: e, span: span } ast::Field { ident: respan(span, name), expr: e, span: span }
} }
fn expr_struct(&self, span: Span, path: ast::Path, fields: Vec<ast::Field>) -> P<ast::Expr> { fn expr_struct(&self, span: Span, path: ast::Path, fields: Vec<ast::Field>) -> P<ast::Expr> {
self.expr(span, ast::ExprStruct(path, fields, None)) self.expr(span, ast::ExprKind::Struct(path, fields, None))
} }
fn expr_struct_ident(&self, span: Span, fn expr_struct_ident(&self, span: Span,
id: ast::Ident, fields: Vec<ast::Field>) -> P<ast::Expr> { id: ast::Ident, fields: Vec<ast::Field>) -> P<ast::Expr> {
@ -677,7 +677,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
} }
fn expr_lit(&self, sp: Span, lit: ast::Lit_) -> P<ast::Expr> { fn expr_lit(&self, sp: Span, lit: ast::Lit_) -> P<ast::Expr> {
self.expr(sp, ast::ExprLit(P(respan(sp, lit)))) self.expr(sp, ast::ExprKind::Lit(P(respan(sp, lit))))
} }
fn expr_usize(&self, span: Span, i: usize) -> P<ast::Expr> { fn expr_usize(&self, span: Span, i: usize) -> P<ast::Expr> {
self.expr_lit(span, ast::LitInt(i as u64, ast::UnsignedIntLit(ast::TyUs))) self.expr_lit(span, ast::LitInt(i as u64, ast::UnsignedIntLit(ast::TyUs)))
@ -697,7 +697,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
} }
fn expr_vec(&self, sp: Span, exprs: Vec<P<ast::Expr>>) -> P<ast::Expr> { fn expr_vec(&self, sp: Span, exprs: Vec<P<ast::Expr>>) -> P<ast::Expr> {
self.expr(sp, ast::ExprVec(exprs)) self.expr(sp, ast::ExprKind::Vec(exprs))
} }
fn expr_vec_ng(&self, sp: Span) -> P<ast::Expr> { fn expr_vec_ng(&self, sp: Span) -> P<ast::Expr> {
self.expr_call_global(sp, self.std_path(&["vec", "Vec", "new"]), self.expr_call_global(sp, self.std_path(&["vec", "Vec", "new"]),
@ -711,7 +711,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
} }
fn expr_cast(&self, sp: Span, expr: P<ast::Expr>, ty: P<ast::Ty>) -> P<ast::Expr> { fn expr_cast(&self, sp: Span, expr: P<ast::Expr>, ty: P<ast::Ty>) -> P<ast::Expr> {
self.expr(sp, ast::ExprCast(expr, ty)) self.expr(sp, ast::ExprKind::Cast(expr, ty))
} }
@ -728,12 +728,12 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn expr_break(&self, sp: Span) -> P<ast::Expr> { fn expr_break(&self, sp: Span) -> P<ast::Expr> {
self.expr(sp, ast::ExprBreak(None)) self.expr(sp, ast::ExprKind::Break(None))
} }
fn expr_tuple(&self, sp: Span, exprs: Vec<P<ast::Expr>>) -> P<ast::Expr> { fn expr_tuple(&self, sp: Span, exprs: Vec<P<ast::Expr>>) -> P<ast::Expr> {
self.expr(sp, ast::ExprTup(exprs)) self.expr(sp, ast::ExprKind::Tup(exprs))
} }
fn expr_fail(&self, span: Span, msg: InternedString) -> P<ast::Expr> { fn expr_fail(&self, span: Span, msg: InternedString) -> P<ast::Expr> {
@ -785,7 +785,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
let err_inner_expr = self.expr_call(sp, self.expr_path(err_path), let err_inner_expr = self.expr_call(sp, self.expr_path(err_path),
vec!(binding_expr.clone())); vec!(binding_expr.clone()));
// return Err(__try_var) // return Err(__try_var)
let err_expr = self.expr(sp, ast::ExprRet(Some(err_inner_expr))); let err_expr = self.expr(sp, ast::ExprKind::Ret(Some(err_inner_expr)));
// Ok(__try_var) => __try_var // Ok(__try_var) => __try_var
let ok_arm = self.arm(sp, vec!(ok_pat), binding_expr); let ok_arm = self.arm(sp, vec!(ok_pat), binding_expr);
@ -868,29 +868,29 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
} }
fn expr_match(&self, span: Span, arg: P<ast::Expr>, arms: Vec<ast::Arm>) -> P<Expr> { fn expr_match(&self, span: Span, arg: P<ast::Expr>, arms: Vec<ast::Arm>) -> P<Expr> {
self.expr(span, ast::ExprMatch(arg, arms)) self.expr(span, ast::ExprKind::Match(arg, arms))
} }
fn expr_if(&self, span: Span, cond: P<ast::Expr>, fn expr_if(&self, span: Span, cond: P<ast::Expr>,
then: P<ast::Expr>, els: Option<P<ast::Expr>>) -> P<ast::Expr> { then: P<ast::Expr>, els: Option<P<ast::Expr>>) -> P<ast::Expr> {
let els = els.map(|x| self.expr_block(self.block_expr(x))); let els = els.map(|x| self.expr_block(self.block_expr(x)));
self.expr(span, ast::ExprIf(cond, self.block_expr(then), els)) self.expr(span, ast::ExprKind::If(cond, self.block_expr(then), els))
} }
fn expr_loop(&self, span: Span, block: P<ast::Block>) -> P<ast::Expr> { fn expr_loop(&self, span: Span, block: P<ast::Block>) -> P<ast::Expr> {
self.expr(span, ast::ExprLoop(block, None)) self.expr(span, ast::ExprKind::Loop(block, None))
} }
fn lambda_fn_decl(&self, span: Span, fn lambda_fn_decl(&self, span: Span,
fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) -> P<ast::Expr> { fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) -> P<ast::Expr> {
self.expr(span, ast::ExprClosure(ast::CaptureBy::Ref, fn_decl, blk)) self.expr(span, ast::ExprKind::Closure(ast::CaptureBy::Ref, fn_decl, blk))
} }
fn lambda(&self, span: Span, ids: Vec<ast::Ident>, blk: P<ast::Block>) -> P<ast::Expr> { fn lambda(&self, span: Span, ids: Vec<ast::Ident>, blk: P<ast::Block>) -> P<ast::Expr> {
let fn_decl = self.fn_decl( let fn_decl = self.fn_decl(
ids.iter().map(|id| self.arg(span, *id, self.ty_infer(span))).collect(), ids.iter().map(|id| self.arg(span, *id, self.ty_infer(span))).collect(),
self.ty_infer(span)); self.ty_infer(span));
self.expr(span, ast::ExprClosure(ast::CaptureBy::Ref, fn_decl, blk)) self.expr(span, ast::ExprKind::Closure(ast::CaptureBy::Ref, fn_decl, blk))
} }
fn lambda0(&self, span: Span, blk: P<ast::Block>) -> P<ast::Expr> { fn lambda0(&self, span: Span, blk: P<ast::Block>) -> P<ast::Expr> {
self.lambda(span, Vec::new(), blk) self.lambda(span, Vec::new(), blk)

40
src/libsyntax/ext/expand.rs
View file

@ -42,7 +42,7 @@ pub fn expand_expr(e: P<ast::Expr>, fld: &mut MacroExpander) -> P<ast::Expr> {
// expr_mac should really be expr_ext or something; it's the // expr_mac should really be expr_ext or something; it's the
// entry-point for all syntax extensions. // entry-point for all syntax extensions.
ast::ExprMac(mac) => { ast::ExprKind::Mac(mac) => {
// Assert that we drop any macro attributes on the floor here // Assert that we drop any macro attributes on the floor here
drop(attrs); drop(attrs);
@ -69,7 +69,7 @@ pub fn expand_expr(e: P<ast::Expr>, fld: &mut MacroExpander) -> P<ast::Expr> {
}) })
} }
ast::ExprInPlace(placer, value_expr) => { ast::ExprKind::InPlace(placer, value_expr) => {
// Ensure feature-gate is enabled // Ensure feature-gate is enabled
feature_gate::check_for_placement_in( feature_gate::check_for_placement_in(
fld.cx.ecfg.features, fld.cx.ecfg.features,
@ -78,18 +78,18 @@ pub fn expand_expr(e: P<ast::Expr>, fld: &mut MacroExpander) -> P<ast::Expr> {
let placer = fld.fold_expr(placer); let placer = fld.fold_expr(placer);
let value_expr = fld.fold_expr(value_expr); let value_expr = fld.fold_expr(value_expr);
fld.cx.expr(span, ast::ExprInPlace(placer, value_expr)) fld.cx.expr(span, ast::ExprKind::InPlace(placer, value_expr))
.with_attrs(fold_thin_attrs(attrs, fld)) .with_attrs(fold_thin_attrs(attrs, fld))
} }
ast::ExprWhile(cond, body, opt_ident) => { ast::ExprKind::While(cond, body, opt_ident) => {
let cond = fld.fold_expr(cond); let cond = fld.fold_expr(cond);
let (body, opt_ident) = expand_loop_block(body, opt_ident, fld); let (body, opt_ident) = expand_loop_block(body, opt_ident, fld);
fld.cx.expr(span, ast::ExprWhile(cond, body, opt_ident)) fld.cx.expr(span, ast::ExprKind::While(cond, body, opt_ident))
.with_attrs(fold_thin_attrs(attrs, fld)) .with_attrs(fold_thin_attrs(attrs, fld))
} }
ast::ExprWhileLet(pat, expr, body, opt_ident) => { ast::ExprKind::WhileLet(pat, expr, body, opt_ident) => {
let pat = fld.fold_pat(pat); let pat = fld.fold_pat(pat);
let expr = fld.fold_expr(expr); let expr = fld.fold_expr(expr);
@ -103,17 +103,17 @@ pub fn expand_expr(e: P<ast::Expr>, fld: &mut MacroExpander) -> P<ast::Expr> {
}); });
assert!(rewritten_pats.len() == 1); assert!(rewritten_pats.len() == 1);
fld.cx.expr(span, ast::ExprWhileLet(rewritten_pats.remove(0), expr, body, opt_ident)) let wl = ast::ExprKind::WhileLet(rewritten_pats.remove(0), expr, body, opt_ident);
.with_attrs(fold_thin_attrs(attrs, fld)) fld.cx.expr(span, wl).with_attrs(fold_thin_attrs(attrs, fld))
} }
ast::ExprLoop(loop_block, opt_ident) => { ast::ExprKind::Loop(loop_block, opt_ident) => {
let (loop_block, opt_ident) = expand_loop_block(loop_block, opt_ident, fld); let (loop_block, opt_ident) = expand_loop_block(loop_block, opt_ident, fld);
fld.cx.expr(span, ast::ExprLoop(loop_block, opt_ident)) fld.cx.expr(span, ast::ExprKind::Loop(loop_block, opt_ident))
.with_attrs(fold_thin_attrs(attrs, fld)) .with_attrs(fold_thin_attrs(attrs, fld))
} }
ast::ExprForLoop(pat, head, body, opt_ident) => { ast::ExprKind::ForLoop(pat, head, body, opt_ident) => {
let pat = fld.fold_pat(pat); let pat = fld.fold_pat(pat);
// Hygienic renaming of the for loop body (for loop binds its pattern). // Hygienic renaming of the for loop body (for loop binds its pattern).
@ -127,11 +127,11 @@ pub fn expand_expr(e: P<ast::Expr>, fld: &mut MacroExpander) -> P<ast::Expr> {
assert!(rewritten_pats.len() == 1); assert!(rewritten_pats.len() == 1);
let head = fld.fold_expr(head); let head = fld.fold_expr(head);
fld.cx.expr(span, ast::ExprForLoop(rewritten_pats.remove(0), head, body, opt_ident)) let fl = ast::ExprKind::ForLoop(rewritten_pats.remove(0), head, body, opt_ident);
.with_attrs(fold_thin_attrs(attrs, fld)) fld.cx.expr(span, fl).with_attrs(fold_thin_attrs(attrs, fld))
} }
ast::ExprIfLet(pat, sub_expr, body, else_opt) => { ast::ExprKind::IfLet(pat, sub_expr, body, else_opt) => {
let pat = fld.fold_pat(pat); let pat = fld.fold_pat(pat);
// Hygienic renaming of the body. // Hygienic renaming of the body.
@ -146,14 +146,14 @@ pub fn expand_expr(e: P<ast::Expr>, fld: &mut MacroExpander) -> P<ast::Expr> {
let else_opt = else_opt.map(|else_opt| fld.fold_expr(else_opt)); let else_opt = else_opt.map(|else_opt| fld.fold_expr(else_opt));
let sub_expr = fld.fold_expr(sub_expr); let sub_expr = fld.fold_expr(sub_expr);
fld.cx.expr(span, ast::ExprIfLet(rewritten_pats.remove(0), sub_expr, body, else_opt)) let il = ast::ExprKind::IfLet(rewritten_pats.remove(0), sub_expr, body, else_opt);
.with_attrs(fold_thin_attrs(attrs, fld)) fld.cx.expr(span, il).with_attrs(fold_thin_attrs(attrs, fld))
} }
ast::ExprClosure(capture_clause, fn_decl, block) => { ast::ExprKind::Closure(capture_clause, fn_decl, block) => {
let (rewritten_fn_decl, rewritten_block) let (rewritten_fn_decl, rewritten_block)
= expand_and_rename_fn_decl_and_block(fn_decl, block, fld); = expand_and_rename_fn_decl_and_block(fn_decl, block, fld);
let new_node = ast::ExprClosure(capture_clause, let new_node = ast::ExprKind::Closure(capture_clause,
rewritten_fn_decl, rewritten_fn_decl,
rewritten_block); rewritten_block);
P(ast::Expr{id:id, node: new_node, span: fld.new_span(span), P(ast::Expr{id:id, node: new_node, span: fld.new_span(span),
@ -1427,7 +1427,7 @@ mod tests {
impl<'v> Visitor<'v> for PathExprFinderContext { impl<'v> Visitor<'v> for PathExprFinderContext {
fn visit_expr(&mut self, expr: &ast::Expr) { fn visit_expr(&mut self, expr: &ast::Expr) {
if let ast::ExprPath(None, ref p) = expr.node { if let ast::ExprKind::Path(None, ref p) = expr.node {
self.path_accumulator.push(p.clone()); self.path_accumulator.push(p.clone());
} }
visit::walk_expr(self, expr); visit::walk_expr(self, expr);
@ -1694,7 +1694,7 @@ mod tests {
0) 0)
} }
// closure arg hygiene (ExprClosure) // closure arg hygiene (ExprKind::Closure)
// expands to fn f(){(|x_1 : i32| {(x_2 + x_1)})(3);} // expands to fn f(){(|x_1 : i32| {(x_2 + x_1)})(3);}
#[test] #[test]
fn closure_arg_hygiene(){ fn closure_arg_hygiene(){

2
src/libsyntax/ext/quote.rs
View file

@ -240,7 +240,7 @@ pub mod rt {
// FIXME: This is wrong // FIXME: This is wrong
P(ast::Expr { P(ast::Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ExprLit(P(self.clone())), node: ast::ExprKind::Lit(P(self.clone())),
span: DUMMY_SP, span: DUMMY_SP,
attrs: None, attrs: None,
}).to_tokens(cx) }).to_tokens(cx)

8
src/libsyntax/feature_gate.rs
View file

@ -815,11 +815,11 @@ impl<'a, 'v> Visitor<'v> for MacroVisitor<'a> {
// But we keep these checks as a pre-expansion check to catch // But we keep these checks as a pre-expansion check to catch
// uses in e.g. conditionalized code. // uses in e.g. conditionalized code.
if let ast::ExprBox(_) = e.node { if let ast::ExprKind::Box(_) = e.node {
self.context.gate_feature("box_syntax", e.span, EXPLAIN_BOX_SYNTAX); self.context.gate_feature("box_syntax", e.span, EXPLAIN_BOX_SYNTAX);
} }
if let ast::ExprInPlace(..) = e.node { if let ast::ExprKind::InPlace(..) = e.node {
self.context.gate_feature("placement_in_syntax", e.span, EXPLAIN_PLACEMENT_IN); self.context.gate_feature("placement_in_syntax", e.span, EXPLAIN_PLACEMENT_IN);
} }
@ -988,13 +988,13 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
fn visit_expr(&mut self, e: &ast::Expr) { fn visit_expr(&mut self, e: &ast::Expr) {
match e.node { match e.node {
ast::ExprBox(_) => { ast::ExprKind::Box(_) => {
self.gate_feature("box_syntax", self.gate_feature("box_syntax",
e.span, e.span,
"box expression syntax is experimental; \ "box expression syntax is experimental; \
you can call `Box::new` instead."); you can call `Box::new` instead.");
} }
ast::ExprType(..) => { ast::ExprKind::Type(..) => {
self.gate_feature("type_ascription", e.span, self.gate_feature("type_ascription", e.span,
"type ascription is experimental"); "type ascription is experimental");
} }

126
src/libsyntax/fold.rs
View file

@ -1168,131 +1168,131 @@ pub fn noop_fold_expr<T: Folder>(Expr {id, node, span, attrs}: Expr, folder: &mu
Expr { Expr {
id: folder.new_id(id), id: folder.new_id(id),
node: match node { node: match node {
ExprBox(e) => { ExprKind::Box(e) => {
ExprBox(folder.fold_expr(e)) ExprKind::Box(folder.fold_expr(e))
} }
ExprInPlace(p, e) => { ExprKind::InPlace(p, e) => {
ExprInPlace(folder.fold_expr(p), folder.fold_expr(e)) ExprKind::InPlace(folder.fold_expr(p), folder.fold_expr(e))
} }
ExprVec(exprs) => { ExprKind::Vec(exprs) => {
ExprVec(folder.fold_exprs(exprs)) ExprKind::Vec(folder.fold_exprs(exprs))
} }
ExprRepeat(expr, count) => { ExprKind::Repeat(expr, count) => {
ExprRepeat(folder.fold_expr(expr), folder.fold_expr(count)) ExprKind::Repeat(folder.fold_expr(expr), folder.fold_expr(count))
} }
ExprTup(exprs) => ExprTup(folder.fold_exprs(exprs)), ExprKind::Tup(exprs) => ExprKind::Tup(folder.fold_exprs(exprs)),
ExprCall(f, args) => { ExprKind::Call(f, args) => {
ExprCall(folder.fold_expr(f), ExprKind::Call(folder.fold_expr(f),
folder.fold_exprs(args)) folder.fold_exprs(args))
} }
ExprMethodCall(i, tps, args) => { ExprKind::MethodCall(i, tps, args) => {
ExprMethodCall( ExprKind::MethodCall(
respan(folder.new_span(i.span), folder.fold_ident(i.node)), respan(folder.new_span(i.span), folder.fold_ident(i.node)),
tps.move_map(|x| folder.fold_ty(x)), tps.move_map(|x| folder.fold_ty(x)),
folder.fold_exprs(args)) folder.fold_exprs(args))
} }
ExprBinary(binop, lhs, rhs) => { ExprKind::Binary(binop, lhs, rhs) => {
ExprBinary(binop, ExprKind::Binary(binop,
folder.fold_expr(lhs), folder.fold_expr(lhs),
folder.fold_expr(rhs)) folder.fold_expr(rhs))
} }
ExprUnary(binop, ohs) => { ExprKind::Unary(binop, ohs) => {
ExprUnary(binop, folder.fold_expr(ohs)) ExprKind::Unary(binop, folder.fold_expr(ohs))
} }
ExprLit(l) => ExprLit(l), ExprKind::Lit(l) => ExprKind::Lit(l),
ExprCast(expr, ty) => { ExprKind::Cast(expr, ty) => {
ExprCast(folder.fold_expr(expr), folder.fold_ty(ty)) ExprKind::Cast(folder.fold_expr(expr), folder.fold_ty(ty))
} }
ExprType(expr, ty) => { ExprKind::Type(expr, ty) => {
ExprType(folder.fold_expr(expr), folder.fold_ty(ty)) ExprKind::Type(folder.fold_expr(expr), folder.fold_ty(ty))
} }
ExprAddrOf(m, ohs) => ExprAddrOf(m, folder.fold_expr(ohs)), ExprKind::AddrOf(m, ohs) => ExprKind::AddrOf(m, folder.fold_expr(ohs)),
ExprIf(cond, tr, fl) => { ExprKind::If(cond, tr, fl) => {
ExprIf(folder.fold_expr(cond), ExprKind::If(folder.fold_expr(cond),
folder.fold_block(tr), folder.fold_block(tr),
fl.map(|x| folder.fold_expr(x))) fl.map(|x| folder.fold_expr(x)))
} }
ExprIfLet(pat, expr, tr, fl) => { ExprKind::IfLet(pat, expr, tr, fl) => {
ExprIfLet(folder.fold_pat(pat), ExprKind::IfLet(folder.fold_pat(pat),
folder.fold_expr(expr), folder.fold_expr(expr),
folder.fold_block(tr), folder.fold_block(tr),
fl.map(|x| folder.fold_expr(x))) fl.map(|x| folder.fold_expr(x)))
} }
ExprWhile(cond, body, opt_ident) => { ExprKind::While(cond, body, opt_ident) => {
ExprWhile(folder.fold_expr(cond), ExprKind::While(folder.fold_expr(cond),
folder.fold_block(body), folder.fold_block(body),
opt_ident.map(|i| folder.fold_ident(i))) opt_ident.map(|i| folder.fold_ident(i)))
} }
ExprWhileLet(pat, expr, body, opt_ident) => { ExprKind::WhileLet(pat, expr, body, opt_ident) => {
ExprWhileLet(folder.fold_pat(pat), ExprKind::WhileLet(folder.fold_pat(pat),
folder.fold_expr(expr), folder.fold_expr(expr),
folder.fold_block(body), folder.fold_block(body),
opt_ident.map(|i| folder.fold_ident(i))) opt_ident.map(|i| folder.fold_ident(i)))
} }
ExprForLoop(pat, iter, body, opt_ident) => { ExprKind::ForLoop(pat, iter, body, opt_ident) => {
ExprForLoop(folder.fold_pat(pat), ExprKind::ForLoop(folder.fold_pat(pat),
folder.fold_expr(iter), folder.fold_expr(iter),
folder.fold_block(body), folder.fold_block(body),
opt_ident.map(|i| folder.fold_ident(i))) opt_ident.map(|i| folder.fold_ident(i)))
} }
ExprLoop(body, opt_ident) => { ExprKind::Loop(body, opt_ident) => {
ExprLoop(folder.fold_block(body), ExprKind::Loop(folder.fold_block(body),
opt_ident.map(|i| folder.fold_ident(i))) opt_ident.map(|i| folder.fold_ident(i)))
} }
ExprMatch(expr, arms) => { ExprKind::Match(expr, arms) => {
ExprMatch(folder.fold_expr(expr), ExprKind::Match(folder.fold_expr(expr),
arms.move_map(|x| folder.fold_arm(x))) arms.move_map(|x| folder.fold_arm(x)))
} }
ExprClosure(capture_clause, decl, body) => { ExprKind::Closure(capture_clause, decl, body) => {
ExprClosure(capture_clause, ExprKind::Closure(capture_clause,
folder.fold_fn_decl(decl), folder.fold_fn_decl(decl),
folder.fold_block(body)) folder.fold_block(body))
} }
ExprBlock(blk) => ExprBlock(folder.fold_block(blk)), ExprKind::Block(blk) => ExprKind::Block(folder.fold_block(blk)),
ExprAssign(el, er) => { ExprKind::Assign(el, er) => {
ExprAssign(folder.fold_expr(el), folder.fold_expr(er)) ExprKind::Assign(folder.fold_expr(el), folder.fold_expr(er))
} }
ExprAssignOp(op, el, er) => { ExprKind::AssignOp(op, el, er) => {
ExprAssignOp(op, ExprKind::AssignOp(op,
folder.fold_expr(el), folder.fold_expr(el),
folder.fold_expr(er)) folder.fold_expr(er))
} }
ExprField(el, ident) => { ExprKind::Field(el, ident) => {
ExprField(folder.fold_expr(el), ExprKind::Field(folder.fold_expr(el),
respan(folder.new_span(ident.span), respan(folder.new_span(ident.span),
folder.fold_ident(ident.node))) folder.fold_ident(ident.node)))
} }
ExprTupField(el, ident) => { ExprKind::TupField(el, ident) => {
ExprTupField(folder.fold_expr(el), ExprKind::TupField(folder.fold_expr(el),
respan(folder.new_span(ident.span), respan(folder.new_span(ident.span),
folder.fold_usize(ident.node))) folder.fold_usize(ident.node)))
} }
ExprIndex(el, er) => { ExprKind::Index(el, er) => {
ExprIndex(folder.fold_expr(el), folder.fold_expr(er)) ExprKind::Index(folder.fold_expr(el), folder.fold_expr(er))
} }
ExprRange(e1, e2) => { ExprKind::Range(e1, e2) => {
ExprRange(e1.map(|x| folder.fold_expr(x)), ExprKind::Range(e1.map(|x| folder.fold_expr(x)),
e2.map(|x| folder.fold_expr(x))) e2.map(|x| folder.fold_expr(x)))
} }
ExprPath(qself, path) => { ExprKind::Path(qself, path) => {
let qself = qself.map(|QSelf { ty, position }| { let qself = qself.map(|QSelf { ty, position }| {
QSelf { QSelf {
ty: folder.fold_ty(ty), ty: folder.fold_ty(ty),
position: position position: position
} }
}); });
ExprPath(qself, folder.fold_path(path)) ExprKind::Path(qself, folder.fold_path(path))
} }
ExprBreak(opt_ident) => ExprBreak(opt_ident.map(|label| ExprKind::Break(opt_ident) => ExprKind::Break(opt_ident.map(|label|
respan(folder.new_span(label.span), respan(folder.new_span(label.span),
folder.fold_ident(label.node))) folder.fold_ident(label.node)))
), ),
ExprAgain(opt_ident) => ExprAgain(opt_ident.map(|label| ExprKind::Again(opt_ident) => ExprKind::Again(opt_ident.map(|label|
respan(folder.new_span(label.span), respan(folder.new_span(label.span),
folder.fold_ident(label.node))) folder.fold_ident(label.node)))
), ),
ExprRet(e) => ExprRet(e.map(|x| folder.fold_expr(x))), ExprKind::Ret(e) => ExprKind::Ret(e.map(|x| folder.fold_expr(x))),
ExprInlineAsm(InlineAsm { ExprKind::InlineAsm(InlineAsm {
inputs, inputs,
outputs, outputs,
asm, asm,
@ -1302,7 +1302,7 @@ pub fn noop_fold_expr<T: Folder>(Expr {id, node, span, attrs}: Expr, folder: &mu
alignstack, alignstack,
dialect, dialect,
expn_id, expn_id,
}) => ExprInlineAsm(InlineAsm { }) => ExprKind::InlineAsm(InlineAsm {
inputs: inputs.move_map(|(c, input)| { inputs: inputs.move_map(|(c, input)| {
(c, folder.fold_expr(input)) (c, folder.fold_expr(input))
}), }),
@ -1322,13 +1322,13 @@ pub fn noop_fold_expr<T: Folder>(Expr {id, node, span, attrs}: Expr, folder: &mu
dialect: dialect, dialect: dialect,
expn_id: expn_id, expn_id: expn_id,
}), }),
ExprMac(mac) => ExprMac(folder.fold_mac(mac)), ExprKind::Mac(mac) => ExprKind::Mac(folder.fold_mac(mac)),
ExprStruct(path, fields, maybe_expr) => { ExprKind::Struct(path, fields, maybe_expr) => {
ExprStruct(folder.fold_path(path), ExprKind::Struct(folder.fold_path(path),
fields.move_map(|x| folder.fold_field(x)), fields.move_map(|x| folder.fold_field(x)),
maybe_expr.map(|x| folder.fold_expr(x))) maybe_expr.map(|x| folder.fold_expr(x)))
}, },
ExprParen(ex) => ExprParen(folder.fold_expr(ex)) ExprKind::Paren(ex) => ExprKind::Paren(folder.fold_expr(ex))
}, },
span: folder.new_span(span), span: folder.new_span(span),
attrs: attrs.map_thin_attrs(|v| fold_attrs(v, folder)), attrs: attrs.map_thin_attrs(|v| fold_attrs(v, folder)),

18
src/libsyntax/parse/classify.rs
View file

@ -23,21 +23,21 @@ use ast::{self, BlockCheckMode};
/// isn't parsed as (if true {...} else {...} | x) | 5 /// isn't parsed as (if true {...} else {...} | x) | 5
pub fn expr_requires_semi_to_be_stmt(e: &ast::Expr) -> bool { pub fn expr_requires_semi_to_be_stmt(e: &ast::Expr) -> bool {
match e.node { match e.node {
ast::ExprIf(..) | ast::ExprKind::If(..) |
ast::ExprIfLet(..) | ast::ExprKind::IfLet(..) |
ast::ExprMatch(..) | ast::ExprKind::Match(..) |
ast::ExprBlock(_) | ast::ExprKind::Block(_) |
ast::ExprWhile(..) | ast::ExprKind::While(..) |
ast::ExprWhileLet(..) | ast::ExprKind::WhileLet(..) |
ast::ExprLoop(..) | ast::ExprKind::Loop(..) |
ast::ExprForLoop(..) => false, ast::ExprKind::ForLoop(..) => false,
_ => true, _ => true,
} }
} }
pub fn expr_is_simple_block(e: &ast::Expr) -> bool { pub fn expr_is_simple_block(e: &ast::Expr) -> bool {
match e.node { match e.node {
ast::ExprBlock(ref block) => block.rules == BlockCheckMode::Default, ast::ExprKind::Block(ref block) => block.rules == BlockCheckMode::Default,
_ => false, _ => false,
} }
} }

14
src/libsyntax/parse/mod.rs
View file

@ -703,7 +703,7 @@ mod tests {
assert!(string_to_expr("a".to_string()) == assert!(string_to_expr("a".to_string()) ==
P(ast::Expr{ P(ast::Expr{
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(None, ast::Path { node: ast::ExprKind::Path(None, ast::Path {
span: sp(0, 1), span: sp(0, 1),
global: false, global: false,
segments: vec!( segments: vec!(
@ -722,7 +722,7 @@ mod tests {
assert!(string_to_expr("::a::b".to_string()) == assert!(string_to_expr("::a::b".to_string()) ==
P(ast::Expr { P(ast::Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(None, ast::Path { node: ast::ExprKind::Path(None, ast::Path {
span: sp(0, 6), span: sp(0, 6),
global: true, global: true,
segments: vec!( segments: vec!(
@ -852,9 +852,9 @@ mod tests {
assert!(string_to_expr("return d".to_string()) == assert!(string_to_expr("return d".to_string()) ==
P(ast::Expr{ P(ast::Expr{
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node:ast::ExprRet(Some(P(ast::Expr{ node:ast::ExprKind::Ret(Some(P(ast::Expr{
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node:ast::ExprPath(None, ast::Path{ node:ast::ExprKind::Path(None, ast::Path{
span: sp(7, 8), span: sp(7, 8),
global: false, global: false,
segments: vec!( segments: vec!(
@ -877,7 +877,7 @@ mod tests {
Some(P(Spanned{ Some(P(Spanned{
node: ast::StmtExpr(P(ast::Expr { node: ast::StmtExpr(P(ast::Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(None, ast::Path { node: ast::ExprKind::Path(None, ast::Path {
span:sp(0,1), span:sp(0,1),
global:false, global:false,
segments: vec!( segments: vec!(
@ -968,7 +968,7 @@ mod tests {
stmts: vec!(P(Spanned{ stmts: vec!(P(Spanned{
node: ast::StmtSemi(P(ast::Expr{ node: ast::StmtSemi(P(ast::Expr{
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(None, node: ast::ExprKind::Path(None,
ast::Path{ ast::Path{
span:sp(17,18), span:sp(17,18),
global:false, global:false,
@ -1110,7 +1110,7 @@ mod tests {
"foo!( fn main() { body } )".to_string(), vec![], &sess); "foo!( fn main() { body } )".to_string(), vec![], &sess);
let tts = match expr.node { let tts = match expr.node {
ast::ExprMac(ref mac) => mac.node.tts.clone(), ast::ExprKind::Mac(ref mac) => mac.node.tts.clone(),
_ => panic!("not a macro"), _ => panic!("not a macro"),
}; };

142
src/libsyntax/parse/parser.rs
View file

@ -20,14 +20,8 @@ use ast::{BlockCheckMode, CaptureBy};
use ast::{Constness, ConstTraitItem, Crate, CrateConfig}; use ast::{Constness, ConstTraitItem, Crate, CrateConfig};
use ast::{Decl, DeclKind}; use ast::{Decl, DeclKind};
use ast::{EMPTY_CTXT, EnumDef, ExplicitSelf}; use ast::{EMPTY_CTXT, EnumDef, ExplicitSelf};
use ast::{Expr, Expr_, ExprAddrOf, ExprMatch, ExprAgain}; use ast::{Expr, ExprKind};
use ast::{ExprAssign, ExprAssignOp, ExprBinary, ExprBlock, ExprBox}; use ast::{Field, FnDecl};
use ast::{ExprBreak, ExprCall, ExprCast, ExprInPlace};
use ast::{ExprField, ExprTupField, ExprClosure, ExprIf, ExprIfLet, ExprIndex};
use ast::{ExprLit, ExprLoop, ExprMac, ExprRange};
use ast::{ExprMethodCall, ExprParen, ExprPath};
use ast::{ExprRepeat, ExprRet, ExprStruct, ExprTup, ExprType, ExprUnary};
use ast::{ExprVec, ExprWhile, ExprWhileLet, ExprForLoop, Field, FnDecl};
use ast::{ForeignItem, ForeignItemStatic, ForeignItemFn, FunctionRetTy}; use ast::{ForeignItem, ForeignItemStatic, ForeignItemFn, FunctionRetTy};
use ast::{Ident, Inherited, ImplItem, Item, Item_, ItemStatic}; use ast::{Ident, Inherited, ImplItem, Item, Item_, ItemStatic};
use ast::{ItemEnum, ItemFn, ItemForeignMod, ItemImpl, ItemConst}; use ast::{ItemEnum, ItemFn, ItemForeignMod, ItemImpl, ItemConst};
@ -140,7 +134,7 @@ macro_rules! maybe_whole_expr {
_ => unreachable!() _ => unreachable!()
}; };
let span = $p.span; let span = $p.span;
Some($p.mk_expr(span.lo, span.hi, ExprPath(None, pt), None)) Some($p.mk_expr(span.lo, span.hi, ExprKind::Path(None, pt), None))
} }
token::Interpolated(token::NtBlock(_)) => { token::Interpolated(token::NtBlock(_)) => {
// FIXME: The following avoids an issue with lexical borrowck scopes, // FIXME: The following avoids an issue with lexical borrowck scopes,
@ -150,7 +144,7 @@ macro_rules! maybe_whole_expr {
_ => unreachable!() _ => unreachable!()
}; };
let span = $p.span; let span = $p.span;
Some($p.mk_expr(span.lo, span.hi, ExprBlock(b), None)) Some($p.mk_expr(span.lo, span.hi, ExprKind::Block(b), None))
} }
_ => None _ => None
}; };
@ -508,7 +502,7 @@ impl<'a> Parser<'a> {
pub fn commit_expr(&mut self, e: &Expr, edible: &[token::Token], pub fn commit_expr(&mut self, e: &Expr, edible: &[token::Token],
inedible: &[token::Token]) -> PResult<'a, ()> { inedible: &[token::Token]) -> PResult<'a, ()> {
debug!("commit_expr {:?}", e); debug!("commit_expr {:?}", e);
if let ExprPath(..) = e.node { if let ExprKind::Path(..) = e.node {
// might be unit-struct construction; check for recoverableinput error. // might be unit-struct construction; check for recoverableinput error.
let expected = edible.iter() let expected = edible.iter()
.cloned() .cloned()
@ -1529,7 +1523,7 @@ impl<'a> Parser<'a> {
match *tok { match *tok {
token::Interpolated(token::NtExpr(ref v)) => { token::Interpolated(token::NtExpr(ref v)) => {
match v.node { match v.node {
ExprLit(ref lit) => { Ok(lit.node.clone()) } ExprKind::Lit(ref lit) => { Ok(lit.node.clone()) }
_ => { return self.unexpected_last(tok); } _ => { return self.unexpected_last(tok); }
} }
} }
@ -1605,7 +1599,7 @@ impl<'a> Parser<'a> {
let lo = self.span.lo; let lo = self.span.lo;
let literal = P(try!(self.parse_lit())); let literal = P(try!(self.parse_lit()));
let hi = self.last_span.hi; let hi = self.last_span.hi;
let expr = self.mk_expr(lo, hi, ExprLit(literal), None); let expr = self.mk_expr(lo, hi, ExprKind::Lit(literal), None);
if minus_present { if minus_present {
let minus_hi = self.last_span.hi; let minus_hi = self.last_span.hi;
@ -1957,7 +1951,7 @@ impl<'a> Parser<'a> {
} }
pub fn mk_expr(&mut self, lo: BytePos, hi: BytePos, pub fn mk_expr(&mut self, lo: BytePos, hi: BytePos,
node: Expr_, attrs: ThinAttributes) -> P<Expr> { node: ExprKind, attrs: ThinAttributes) -> P<Expr> {
P(Expr { P(Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: node, node: node,
@ -1966,55 +1960,55 @@ impl<'a> Parser<'a> {
}) })
} }
pub fn mk_unary(&mut self, unop: ast::UnOp, expr: P<Expr>) -> ast::Expr_ { pub fn mk_unary(&mut self, unop: ast::UnOp, expr: P<Expr>) -> ast::ExprKind {
ExprUnary(unop, expr) ExprKind::Unary(unop, expr)
} }
pub fn mk_binary(&mut self, binop: ast::BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ast::Expr_ { pub fn mk_binary(&mut self, binop: ast::BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ast::ExprKind {
ExprBinary(binop, lhs, rhs) ExprKind::Binary(binop, lhs, rhs)
} }
pub fn mk_call(&mut self, f: P<Expr>, args: Vec<P<Expr>>) -> ast::Expr_ { pub fn mk_call(&mut self, f: P<Expr>, args: Vec<P<Expr>>) -> ast::ExprKind {
ExprCall(f, args) ExprKind::Call(f, args)
} }
fn mk_method_call(&mut self, fn mk_method_call(&mut self,
ident: ast::SpannedIdent, ident: ast::SpannedIdent,
tps: Vec<P<Ty>>, tps: Vec<P<Ty>>,
args: Vec<P<Expr>>) args: Vec<P<Expr>>)
-> ast::Expr_ { -> ast::ExprKind {
ExprMethodCall(ident, tps, args) ExprKind::MethodCall(ident, tps, args)
} }
pub fn mk_index(&mut self, expr: P<Expr>, idx: P<Expr>) -> ast::Expr_ { pub fn mk_index(&mut self, expr: P<Expr>, idx: P<Expr>) -> ast::ExprKind {
ExprIndex(expr, idx) ExprKind::Index(expr, idx)
} }
pub fn mk_range(&mut self, pub fn mk_range(&mut self,
start: Option<P<Expr>>, start: Option<P<Expr>>,
end: Option<P<Expr>>) end: Option<P<Expr>>)
-> ast::Expr_ { -> ast::ExprKind {
ExprRange(start, end) ExprKind::Range(start, end)
} }
pub fn mk_field(&mut self, expr: P<Expr>, ident: ast::SpannedIdent) -> ast::Expr_ { pub fn mk_field(&mut self, expr: P<Expr>, ident: ast::SpannedIdent) -> ast::ExprKind {
ExprField(expr, ident) ExprKind::Field(expr, ident)
} }
pub fn mk_tup_field(&mut self, expr: P<Expr>, idx: codemap::Spanned<usize>) -> ast::Expr_ { pub fn mk_tup_field(&mut self, expr: P<Expr>, idx: codemap::Spanned<usize>) -> ast::ExprKind {
ExprTupField(expr, idx) ExprKind::TupField(expr, idx)
} }
pub fn mk_assign_op(&mut self, binop: ast::BinOp, pub fn mk_assign_op(&mut self, binop: ast::BinOp,
lhs: P<Expr>, rhs: P<Expr>) -> ast::Expr_ { lhs: P<Expr>, rhs: P<Expr>) -> ast::ExprKind {
ExprAssignOp(binop, lhs, rhs) ExprKind::AssignOp(binop, lhs, rhs)
} }
pub fn mk_mac_expr(&mut self, lo: BytePos, hi: BytePos, pub fn mk_mac_expr(&mut self, lo: BytePos, hi: BytePos,
m: Mac_, attrs: ThinAttributes) -> P<Expr> { m: Mac_, attrs: ThinAttributes) -> P<Expr> {
P(Expr { P(Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ExprMac(codemap::Spanned {node: m, span: mk_sp(lo, hi)}), node: ExprKind::Mac(codemap::Spanned {node: m, span: mk_sp(lo, hi)}),
span: mk_sp(lo, hi), span: mk_sp(lo, hi),
attrs: attrs, attrs: attrs,
}) })
@ -2029,7 +2023,7 @@ impl<'a> Parser<'a> {
P(Expr { P(Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ExprLit(lv_lit), node: ExprKind::Lit(lv_lit),
span: *span, span: *span,
attrs: attrs, attrs: attrs,
}) })
@ -2066,7 +2060,7 @@ impl<'a> Parser<'a> {
let lo = self.span.lo; let lo = self.span.lo;
let mut hi = self.span.hi; let mut hi = self.span.hi;
let ex: Expr_; let ex: ExprKind;
// Note: when adding new syntax here, don't forget to adjust Token::can_begin_expr(). // Note: when adding new syntax here, don't forget to adjust Token::can_begin_expr().
match self.token { match self.token {
@ -2098,9 +2092,9 @@ impl<'a> Parser<'a> {
hi = self.last_span.hi; hi = self.last_span.hi;
return if es.len() == 1 && !trailing_comma { return if es.len() == 1 && !trailing_comma {
Ok(self.mk_expr(lo, hi, ExprParen(es.into_iter().nth(0).unwrap()), attrs)) Ok(self.mk_expr(lo, hi, ExprKind::Paren(es.into_iter().nth(0).unwrap()), attrs))
} else { } else {
Ok(self.mk_expr(lo, hi, ExprTup(es), attrs)) Ok(self.mk_expr(lo, hi, ExprKind::Tup(es), attrs))
} }
}, },
token::OpenDelim(token::Brace) => { token::OpenDelim(token::Brace) => {
@ -2116,7 +2110,7 @@ impl<'a> Parser<'a> {
}, token::Plain) => { }, token::Plain) => {
self.bump(); self.bump();
let path = ast_util::ident_to_path(mk_sp(lo, hi), id); let path = ast_util::ident_to_path(mk_sp(lo, hi), id);
ex = ExprPath(None, path); ex = ExprKind::Path(None, path);
hi = self.last_span.hi; hi = self.last_span.hi;
} }
token::OpenDelim(token::Bracket) => { token::OpenDelim(token::Bracket) => {
@ -2129,7 +2123,7 @@ impl<'a> Parser<'a> {
if self.check(&token::CloseDelim(token::Bracket)) { if self.check(&token::CloseDelim(token::Bracket)) {
// Empty vector. // Empty vector.
self.bump(); self.bump();
ex = ExprVec(Vec::new()); ex = ExprKind::Vec(Vec::new());
} else { } else {
// Nonempty vector. // Nonempty vector.
let first_expr = try!(self.parse_expr()); let first_expr = try!(self.parse_expr());
@ -2138,7 +2132,7 @@ impl<'a> Parser<'a> {
self.bump(); self.bump();
let count = try!(self.parse_expr()); let count = try!(self.parse_expr());
try!(self.expect(&token::CloseDelim(token::Bracket))); try!(self.expect(&token::CloseDelim(token::Bracket)));
ex = ExprRepeat(first_expr, count); ex = ExprKind::Repeat(first_expr, count);
} else if self.check(&token::Comma) { } else if self.check(&token::Comma) {
// Vector with two or more elements. // Vector with two or more elements.
self.bump(); self.bump();
@ -2149,11 +2143,11 @@ impl<'a> Parser<'a> {
)); ));
let mut exprs = vec!(first_expr); let mut exprs = vec!(first_expr);
exprs.extend(remaining_exprs); exprs.extend(remaining_exprs);
ex = ExprVec(exprs); ex = ExprKind::Vec(exprs);
} else { } else {
// Vector with one element. // Vector with one element.
try!(self.expect(&token::CloseDelim(token::Bracket))); try!(self.expect(&token::CloseDelim(token::Bracket)));
ex = ExprVec(vec!(first_expr)); ex = ExprKind::Vec(vec!(first_expr));
} }
} }
hi = self.last_span.hi; hi = self.last_span.hi;
@ -2163,7 +2157,7 @@ impl<'a> Parser<'a> {
let (qself, path) = let (qself, path) =
try!(self.parse_qualified_path(LifetimeAndTypesWithColons)); try!(self.parse_qualified_path(LifetimeAndTypesWithColons));
hi = path.span.hi; hi = path.span.hi;
return Ok(self.mk_expr(lo, hi, ExprPath(Some(qself), path), attrs)); return Ok(self.mk_expr(lo, hi, ExprKind::Path(Some(qself), path), attrs));
} }
if self.eat_keyword(keywords::Move) { if self.eat_keyword(keywords::Move) {
let lo = self.last_span.lo; let lo = self.last_span.lo;
@ -2202,14 +2196,14 @@ impl<'a> Parser<'a> {
} }
if self.eat_keyword(keywords::Continue) { if self.eat_keyword(keywords::Continue) {
let ex = if self.token.is_lifetime() { let ex = if self.token.is_lifetime() {
let ex = ExprAgain(Some(Spanned{ let ex = ExprKind::Again(Some(Spanned{
node: self.get_lifetime(), node: self.get_lifetime(),
span: self.span span: self.span
})); }));
self.bump(); self.bump();
ex ex
} else { } else {
ExprAgain(None) ExprKind::Again(None)
}; };
let hi = self.last_span.hi; let hi = self.last_span.hi;
return Ok(self.mk_expr(lo, hi, ex, attrs)); return Ok(self.mk_expr(lo, hi, ex, attrs));
@ -2227,19 +2221,19 @@ impl<'a> Parser<'a> {
if self.token.can_begin_expr() { if self.token.can_begin_expr() {
let e = try!(self.parse_expr()); let e = try!(self.parse_expr());
hi = e.span.hi; hi = e.span.hi;
ex = ExprRet(Some(e)); ex = ExprKind::Ret(Some(e));
} else { } else {
ex = ExprRet(None); ex = ExprKind::Ret(None);
} }
} else if self.eat_keyword(keywords::Break) { } else if self.eat_keyword(keywords::Break) {
if self.token.is_lifetime() { if self.token.is_lifetime() {
ex = ExprBreak(Some(Spanned { ex = ExprKind::Break(Some(Spanned {
node: self.get_lifetime(), node: self.get_lifetime(),
span: self.span span: self.span
})); }));
self.bump(); self.bump();
} else { } else {
ex = ExprBreak(None); ex = ExprKind::Break(None);
} }
hi = self.last_span.hi; hi = self.last_span.hi;
} else if self.token.is_keyword(keywords::Let) { } else if self.token.is_keyword(keywords::Let) {
@ -2302,18 +2296,18 @@ impl<'a> Parser<'a> {
hi = self.span.hi; hi = self.span.hi;
try!(self.expect(&token::CloseDelim(token::Brace))); try!(self.expect(&token::CloseDelim(token::Brace)));
ex = ExprStruct(pth, fields, base); ex = ExprKind::Struct(pth, fields, base);
return Ok(self.mk_expr(lo, hi, ex, attrs)); return Ok(self.mk_expr(lo, hi, ex, attrs));
} }
} }
hi = pth.span.hi; hi = pth.span.hi;
ex = ExprPath(None, pth); ex = ExprKind::Path(None, pth);
} else { } else {
// other literal expression // other literal expression
let lit = try!(self.parse_lit()); let lit = try!(self.parse_lit());
hi = lit.span.hi; hi = lit.span.hi;
ex = ExprLit(P(lit)); ex = ExprKind::Lit(P(lit));
} }
} }
} }
@ -2343,7 +2337,7 @@ impl<'a> Parser<'a> {
let attrs = outer_attrs.append(inner_attrs); let attrs = outer_attrs.append(inner_attrs);
let blk = try!(self.parse_block_tail(lo, blk_mode)); let blk = try!(self.parse_block_tail(lo, blk_mode));
return Ok(self.mk_expr(blk.span.lo, blk.span.hi, ExprBlock(blk), attrs)); return Ok(self.mk_expr(blk.span.lo, blk.span.hi, ExprKind::Block(blk), attrs));
} }
/// parse a.b or a(13) or a[4] or just a /// parse a.b or a(13) or a[4] or just a
@ -2370,7 +2364,7 @@ impl<'a> Parser<'a> {
expr.map(|mut expr| { expr.map(|mut expr| {
expr.attrs.update(|a| a.prepend(attrs)); expr.attrs.update(|a| a.prepend(attrs));
match expr.node { match expr.node {
ExprIf(..) | ExprIfLet(..) => { ExprKind::If(..) | ExprKind::IfLet(..) => {
if !expr.attrs.as_attr_slice().is_empty() { if !expr.attrs.as_attr_slice().is_empty() {
// Just point to the first attribute in there... // Just point to the first attribute in there...
let span = expr.attrs.as_attr_slice()[0].span; let span = expr.attrs.as_attr_slice()[0].span;
@ -2763,7 +2757,7 @@ impl<'a> Parser<'a> {
let e = self.parse_prefix_expr(None); let e = self.parse_prefix_expr(None);
let (span, e) = try!(self.interpolated_or_expr_span(e)); let (span, e) = try!(self.interpolated_or_expr_span(e));
hi = span.hi; hi = span.hi;
ExprAddrOf(m, e) ExprKind::AddrOf(m, e)
} }
token::Ident(..) if self.token.is_keyword(keywords::In) => { token::Ident(..) if self.token.is_keyword(keywords::In) => {
self.bump(); self.bump();
@ -2774,16 +2768,16 @@ impl<'a> Parser<'a> {
let blk = try!(self.parse_block()); let blk = try!(self.parse_block());
let span = blk.span; let span = blk.span;
hi = span.hi; hi = span.hi;
let blk_expr = self.mk_expr(span.lo, span.hi, ExprBlock(blk), let blk_expr = self.mk_expr(span.lo, span.hi, ExprKind::Block(blk),
None); None);
ExprInPlace(place, blk_expr) ExprKind::InPlace(place, blk_expr)
} }
token::Ident(..) if self.token.is_keyword(keywords::Box) => { token::Ident(..) if self.token.is_keyword(keywords::Box) => {
self.bump(); self.bump();
let e = self.parse_prefix_expr(None); let e = self.parse_prefix_expr(None);
let (span, e) = try!(self.interpolated_or_expr_span(e)); let (span, e) = try!(self.interpolated_or_expr_span(e));
hi = span.hi; hi = span.hi;
ExprBox(e) ExprKind::Box(e)
} }
_ => return self.parse_dot_or_call_expr(Some(attrs)) _ => return self.parse_dot_or_call_expr(Some(attrs))
}; };
@ -2850,12 +2844,12 @@ impl<'a> Parser<'a> {
if op == AssocOp::As { if op == AssocOp::As {
let rhs = try!(self.parse_ty()); let rhs = try!(self.parse_ty());
lhs = self.mk_expr(lhs_span.lo, rhs.span.hi, lhs = self.mk_expr(lhs_span.lo, rhs.span.hi,
ExprCast(lhs, rhs), None); ExprKind::Cast(lhs, rhs), None);
continue continue
} else if op == AssocOp::Colon { } else if op == AssocOp::Colon {
let rhs = try!(self.parse_ty()); let rhs = try!(self.parse_ty());
lhs = self.mk_expr(lhs_span.lo, rhs.span.hi, lhs = self.mk_expr(lhs_span.lo, rhs.span.hi,
ExprType(lhs, rhs), None); ExprKind::Type(lhs, rhs), None);
continue continue
} else if op == AssocOp::DotDot { } else if op == AssocOp::DotDot {
// If we didn’t have to handle `x..`, it would be pretty easy to generalise // If we didn’t have to handle `x..`, it would be pretty easy to generalise
@ -2921,9 +2915,9 @@ impl<'a> Parser<'a> {
self.mk_expr(lhs_span.lo, rhs_span.hi, binary, None) self.mk_expr(lhs_span.lo, rhs_span.hi, binary, None)
} }
AssocOp::Assign => AssocOp::Assign =>
self.mk_expr(lhs_span.lo, rhs.span.hi, ExprAssign(lhs, rhs), None), self.mk_expr(lhs_span.lo, rhs.span.hi, ExprKind::Assign(lhs, rhs), None),
AssocOp::Inplace => AssocOp::Inplace =>
self.mk_expr(lhs_span.lo, rhs.span.hi, ExprInPlace(lhs, rhs), None), self.mk_expr(lhs_span.lo, rhs.span.hi, ExprKind::InPlace(lhs, rhs), None),
AssocOp::AssignOp(k) => { AssocOp::AssignOp(k) => {
let aop = match k { let aop = match k {
token::Plus => BinOpKind::Add, token::Plus => BinOpKind::Add,
@ -2957,7 +2951,7 @@ impl<'a> Parser<'a> {
fn check_no_chained_comparison(&mut self, lhs: &Expr, outer_op: &AssocOp) { fn check_no_chained_comparison(&mut self, lhs: &Expr, outer_op: &AssocOp) {
debug_assert!(outer_op.is_comparison()); debug_assert!(outer_op.is_comparison());
match lhs.node { match lhs.node {
ExprBinary(op, _, _) if op.node.is_comparison() => { ExprKind::Binary(op, _, _) if op.node.is_comparison() => {
// respan to include both operators // respan to include both operators
let op_span = mk_sp(op.span.lo, self.span.hi); let op_span = mk_sp(op.span.lo, self.span.hi);
let mut err = self.diagnostic().struct_span_err(op_span, let mut err = self.diagnostic().struct_span_err(op_span,
@ -3024,7 +3018,7 @@ impl<'a> Parser<'a> {
hi = elexpr.span.hi; hi = elexpr.span.hi;
els = Some(elexpr); els = Some(elexpr);
} }
Ok(self.mk_expr(lo, hi, ExprIf(cond, thn, els), attrs)) Ok(self.mk_expr(lo, hi, ExprKind::If(cond, thn, els), attrs))
} }
/// Parse an 'if let' expression ('if' token already eaten) /// Parse an 'if let' expression ('if' token already eaten)
@ -3042,7 +3036,7 @@ impl<'a> Parser<'a> {
} else { } else {
(thn.span.hi, None) (thn.span.hi, None)
}; };
Ok(self.mk_expr(lo, hi, ExprIfLet(pat, expr, thn, els), attrs)) Ok(self.mk_expr(lo, hi, ExprKind::IfLet(pat, expr, thn, els), attrs))
} }
// `|args| expr` // `|args| expr`
@ -3075,7 +3069,7 @@ impl<'a> Parser<'a> {
Ok(self.mk_expr( Ok(self.mk_expr(
lo, lo,
body.span.hi, body.span.hi,
ExprClosure(capture_clause, decl, body), attrs)) ExprKind::Closure(capture_clause, decl, body), attrs))
} }
// `else` token already eaten // `else` token already eaten
@ -3084,7 +3078,7 @@ impl<'a> Parser<'a> {
return self.parse_if_expr(None); return self.parse_if_expr(None);
} else { } else {
let blk = try!(self.parse_block()); let blk = try!(self.parse_block());
return Ok(self.mk_expr(blk.span.lo, blk.span.hi, ExprBlock(blk), None)); return Ok(self.mk_expr(blk.span.lo, blk.span.hi, ExprKind::Block(blk), None));
} }
} }
@ -3103,7 +3097,7 @@ impl<'a> Parser<'a> {
let hi = self.last_span.hi; let hi = self.last_span.hi;
Ok(self.mk_expr(span_lo, hi, Ok(self.mk_expr(span_lo, hi,
ExprForLoop(pat, expr, loop_block, opt_ident), ExprKind::ForLoop(pat, expr, loop_block, opt_ident),
attrs)) attrs))
} }
@ -3118,7 +3112,7 @@ impl<'a> Parser<'a> {
let (iattrs, body) = try!(self.parse_inner_attrs_and_block()); let (iattrs, body) = try!(self.parse_inner_attrs_and_block());
let attrs = attrs.append(iattrs.into_thin_attrs()); let attrs = attrs.append(iattrs.into_thin_attrs());
let hi = body.span.hi; let hi = body.span.hi;
return Ok(self.mk_expr(span_lo, hi, ExprWhile(cond, body, opt_ident), return Ok(self.mk_expr(span_lo, hi, ExprKind::While(cond, body, opt_ident),
attrs)); attrs));
} }
@ -3133,7 +3127,7 @@ impl<'a> Parser<'a> {
let (iattrs, body) = try!(self.parse_inner_attrs_and_block()); let (iattrs, body) = try!(self.parse_inner_attrs_and_block());
let attrs = attrs.append(iattrs.into_thin_attrs()); let attrs = attrs.append(iattrs.into_thin_attrs());
let hi = body.span.hi; let hi = body.span.hi;
return Ok(self.mk_expr(span_lo, hi, ExprWhileLet(pat, expr, body, opt_ident), attrs)); return Ok(self.mk_expr(span_lo, hi, ExprKind::WhileLet(pat, expr, body, opt_ident), attrs));
} }
// parse `loop {...}`, `loop` token already eaten // parse `loop {...}`, `loop` token already eaten
@ -3143,7 +3137,7 @@ impl<'a> Parser<'a> {
let (iattrs, body) = try!(self.parse_inner_attrs_and_block()); let (iattrs, body) = try!(self.parse_inner_attrs_and_block());
let attrs = attrs.append(iattrs.into_thin_attrs()); let attrs = attrs.append(iattrs.into_thin_attrs());
let hi = body.span.hi; let hi = body.span.hi;
Ok(self.mk_expr(span_lo, hi, ExprLoop(body, opt_ident), attrs)) Ok(self.mk_expr(span_lo, hi, ExprKind::Loop(body, opt_ident), attrs))
} }
// `match` token already eaten // `match` token already eaten
@ -3167,7 +3161,7 @@ impl<'a> Parser<'a> {
} }
let hi = self.span.hi; let hi = self.span.hi;
self.bump(); self.bump();
return Ok(self.mk_expr(lo, hi, ExprMatch(discriminant, arms), attrs)); return Ok(self.mk_expr(lo, hi, ExprKind::Match(discriminant, arms), attrs));
} }
pub fn parse_arm(&mut self) -> PResult<'a, Arm> { pub fn parse_arm(&mut self) -> PResult<'a, Arm> {
@ -3407,7 +3401,7 @@ impl<'a> Parser<'a> {
(None, try!(self.parse_path(LifetimeAndTypesWithColons))) (None, try!(self.parse_path(LifetimeAndTypesWithColons)))
}; };
let hi = self.last_span.hi; let hi = self.last_span.hi;
Ok(self.mk_expr(lo, hi, ExprPath(qself, path), None)) Ok(self.mk_expr(lo, hi, ExprKind::Path(qself, path), None))
} else { } else {
self.parse_pat_literal_maybe_minus() self.parse_pat_literal_maybe_minus()
} }
@ -3509,7 +3503,7 @@ impl<'a> Parser<'a> {
token::DotDotDot => { token::DotDotDot => {
// Parse range // Parse range
let hi = self.last_span.hi; let hi = self.last_span.hi;
let begin = self.mk_expr(lo, hi, ExprPath(qself, path), None); let begin = self.mk_expr(lo, hi, ExprKind::Path(qself, path), None);
self.bump(); self.bump();
let end = try!(self.parse_pat_range_end()); let end = try!(self.parse_pat_range_end());
pat = PatRange(begin, end); pat = PatRange(begin, end);

96
src/libsyntax/print/pprust.rs
View file

@ -441,10 +441,10 @@ pub fn visibility_qualified(vis: ast::Visibility, s: &str) -> String {
fn needs_parentheses(expr: &ast::Expr) -> bool { fn needs_parentheses(expr: &ast::Expr) -> bool {
match expr.node { match expr.node {
ast::ExprAssign(..) | ast::ExprBinary(..) | ast::ExprKind::Assign(..) | ast::ExprKind::Binary(..) |
ast::ExprClosure(..) | ast::ExprKind::Closure(..) |
ast::ExprAssignOp(..) | ast::ExprCast(..) | ast::ExprKind::AssignOp(..) | ast::ExprKind::Cast(..) |
ast::ExprInPlace(..) | ast::ExprType(..) => true, ast::ExprKind::InPlace(..) | ast::ExprKind::Type(..) => true,
_ => false, _ => false,
} }
} }
@ -1713,7 +1713,7 @@ impl<'a> State<'a> {
Some(_else) => { Some(_else) => {
match _else.node { match _else.node {
// "another else-if" // "another else-if"
ast::ExprIf(ref i, ref then, ref e) => { ast::ExprKind::If(ref i, ref then, ref e) => {
try!(self.cbox(INDENT_UNIT - 1)); try!(self.cbox(INDENT_UNIT - 1));
try!(self.ibox(0)); try!(self.ibox(0));
try!(word(&mut self.s, " else if ")); try!(word(&mut self.s, " else if "));
@ -1723,7 +1723,7 @@ impl<'a> State<'a> {
self.print_else(e.as_ref().map(|e| &**e)) self.print_else(e.as_ref().map(|e| &**e))
} }
// "another else-if-let" // "another else-if-let"
ast::ExprIfLet(ref pat, ref expr, ref then, ref e) => { ast::ExprKind::IfLet(ref pat, ref expr, ref then, ref e) => {
try!(self.cbox(INDENT_UNIT - 1)); try!(self.cbox(INDENT_UNIT - 1));
try!(self.ibox(0)); try!(self.ibox(0));
try!(word(&mut self.s, " else if let ")); try!(word(&mut self.s, " else if let "));
@ -1736,7 +1736,7 @@ impl<'a> State<'a> {
self.print_else(e.as_ref().map(|e| &**e)) self.print_else(e.as_ref().map(|e| &**e))
} }
// "final else" // "final else"
ast::ExprBlock(ref b) => { ast::ExprKind::Block(ref b) => {
try!(self.cbox(INDENT_UNIT - 1)); try!(self.cbox(INDENT_UNIT - 1));
try!(self.ibox(0)); try!(self.ibox(0));
try!(word(&mut self.s, " else ")); try!(word(&mut self.s, " else "));
@ -1803,7 +1803,7 @@ impl<'a> State<'a> {
pub fn check_expr_bin_needs_paren(&mut self, sub_expr: &ast::Expr, pub fn check_expr_bin_needs_paren(&mut self, sub_expr: &ast::Expr,
binop: ast::BinOp) -> bool { binop: ast::BinOp) -> bool {
match sub_expr.node { match sub_expr.node {
ast::ExprBinary(ref sub_op, _, _) => { ast::ExprKind::Binary(ref sub_op, _, _) => {
if AssocOp::from_ast_binop(sub_op.node).precedence() < if AssocOp::from_ast_binop(sub_op.node).precedence() <
AssocOp::from_ast_binop(binop.node).precedence() { AssocOp::from_ast_binop(binop.node).precedence() {
true true
@ -1985,45 +1985,45 @@ impl<'a> State<'a> {
try!(self.ibox(INDENT_UNIT)); try!(self.ibox(INDENT_UNIT));
try!(self.ann.pre(self, NodeExpr(expr))); try!(self.ann.pre(self, NodeExpr(expr)));
match expr.node { match expr.node {
ast::ExprBox(ref expr) => { ast::ExprKind::Box(ref expr) => {
try!(self.word_space("box")); try!(self.word_space("box"));
try!(self.print_expr(expr)); try!(self.print_expr(expr));
} }
ast::ExprInPlace(ref place, ref expr) => { ast::ExprKind::InPlace(ref place, ref expr) => {
try!(self.print_expr_in_place(place, expr)); try!(self.print_expr_in_place(place, expr));
} }
ast::ExprVec(ref exprs) => { ast::ExprKind::Vec(ref exprs) => {
try!(self.print_expr_vec(&exprs[..], attrs)); try!(self.print_expr_vec(&exprs[..], attrs));
} }
ast::ExprRepeat(ref element, ref count) => { ast::ExprKind::Repeat(ref element, ref count) => {
try!(self.print_expr_repeat(&**element, &**count, attrs)); try!(self.print_expr_repeat(&**element, &**count, attrs));
} }
ast::ExprStruct(ref path, ref fields, ref wth) => { ast::ExprKind::Struct(ref path, ref fields, ref wth) => {
try!(self.print_expr_struct(path, &fields[..], wth, attrs)); try!(self.print_expr_struct(path, &fields[..], wth, attrs));
} }
ast::ExprTup(ref exprs) => { ast::ExprKind::Tup(ref exprs) => {
try!(self.print_expr_tup(&exprs[..], attrs)); try!(self.print_expr_tup(&exprs[..], attrs));
} }
ast::ExprCall(ref func, ref args) => { ast::ExprKind::Call(ref func, ref args) => {
try!(self.print_expr_call(&**func, &args[..])); try!(self.print_expr_call(&**func, &args[..]));
} }
ast::ExprMethodCall(ident, ref tys, ref args) => { ast::ExprKind::MethodCall(ident, ref tys, ref args) => {
try!(self.print_expr_method_call(ident, &tys[..], &args[..])); try!(self.print_expr_method_call(ident, &tys[..], &args[..]));
} }
ast::ExprBinary(op, ref lhs, ref rhs) => { ast::ExprKind::Binary(op, ref lhs, ref rhs) => {
try!(self.print_expr_binary(op, &**lhs, &**rhs)); try!(self.print_expr_binary(op, &**lhs, &**rhs));
} }
ast::ExprUnary(op, ref expr) => { ast::ExprKind::Unary(op, ref expr) => {
try!(self.print_expr_unary(op, &**expr)); try!(self.print_expr_unary(op, &**expr));
} }
ast::ExprAddrOf(m, ref expr) => { ast::ExprKind::AddrOf(m, ref expr) => {
try!(self.print_expr_addr_of(m, &**expr)); try!(self.print_expr_addr_of(m, &**expr));
} }
ast::ExprLit(ref lit) => { ast::ExprKind::Lit(ref lit) => {
try!(self.print_literal(&**lit)); try!(self.print_literal(&**lit));
} }
ast::ExprCast(ref expr, ref ty) => { ast::ExprKind::Cast(ref expr, ref ty) => {
if let ast::ExprCast(..) = expr.node { if let ast::ExprKind::Cast(..) = expr.node {
try!(self.print_expr(&**expr)); try!(self.print_expr(&**expr));
} else { } else {
try!(self.print_expr_maybe_paren(&**expr)); try!(self.print_expr_maybe_paren(&**expr));
@ -2032,18 +2032,18 @@ impl<'a> State<'a> {
try!(self.word_space("as")); try!(self.word_space("as"));
try!(self.print_type(&**ty)); try!(self.print_type(&**ty));
} }
ast::ExprType(ref expr, ref ty) => { ast::ExprKind::Type(ref expr, ref ty) => {
try!(self.print_expr(&**expr)); try!(self.print_expr(&**expr));
try!(self.word_space(":")); try!(self.word_space(":"));
try!(self.print_type(&**ty)); try!(self.print_type(&**ty));
} }
ast::ExprIf(ref test, ref blk, ref elseopt) => { ast::ExprKind::If(ref test, ref blk, ref elseopt) => {
try!(self.print_if(&**test, &**blk, elseopt.as_ref().map(|e| &**e))); try!(self.print_if(&**test, &**blk, elseopt.as_ref().map(|e| &**e)));
} }
ast::ExprIfLet(ref pat, ref expr, ref blk, ref elseopt) => { ast::ExprKind::IfLet(ref pat, ref expr, ref blk, ref elseopt) => {
try!(self.print_if_let(&**pat, &**expr, &** blk, elseopt.as_ref().map(|e| &**e))); try!(self.print_if_let(&**pat, &**expr, &** blk, elseopt.as_ref().map(|e| &**e)));
} }
ast::ExprWhile(ref test, ref blk, opt_ident) => { ast::ExprKind::While(ref test, ref blk, opt_ident) => {
if let Some(ident) = opt_ident { if let Some(ident) = opt_ident {
try!(self.print_ident(ident)); try!(self.print_ident(ident));
try!(self.word_space(":")); try!(self.word_space(":"));
@ -2053,7 +2053,7 @@ impl<'a> State<'a> {
try!(space(&mut self.s)); try!(space(&mut self.s));
try!(self.print_block_with_attrs(&**blk, attrs)); try!(self.print_block_with_attrs(&**blk, attrs));
} }
ast::ExprWhileLet(ref pat, ref expr, ref blk, opt_ident) => { ast::ExprKind::WhileLet(ref pat, ref expr, ref blk, opt_ident) => {
if let Some(ident) = opt_ident { if let Some(ident) = opt_ident {
try!(self.print_ident(ident)); try!(self.print_ident(ident));
try!(self.word_space(":")); try!(self.word_space(":"));
@ -2066,7 +2066,7 @@ impl<'a> State<'a> {
try!(space(&mut self.s)); try!(space(&mut self.s));
try!(self.print_block_with_attrs(&**blk, attrs)); try!(self.print_block_with_attrs(&**blk, attrs));
} }
ast::ExprForLoop(ref pat, ref iter, ref blk, opt_ident) => { ast::ExprKind::ForLoop(ref pat, ref iter, ref blk, opt_ident) => {
if let Some(ident) = opt_ident { if let Some(ident) = opt_ident {
try!(self.print_ident(ident)); try!(self.print_ident(ident));
try!(self.word_space(":")); try!(self.word_space(":"));
@ -2079,7 +2079,7 @@ impl<'a> State<'a> {
try!(space(&mut self.s)); try!(space(&mut self.s));
try!(self.print_block_with_attrs(&**blk, attrs)); try!(self.print_block_with_attrs(&**blk, attrs));
} }
ast::ExprLoop(ref blk, opt_ident) => { ast::ExprKind::Loop(ref blk, opt_ident) => {
if let Some(ident) = opt_ident { if let Some(ident) = opt_ident {
try!(self.print_ident(ident)); try!(self.print_ident(ident));
try!(self.word_space(":")); try!(self.word_space(":"));
@ -2088,7 +2088,7 @@ impl<'a> State<'a> {
try!(space(&mut self.s)); try!(space(&mut self.s));
try!(self.print_block_with_attrs(&**blk, attrs)); try!(self.print_block_with_attrs(&**blk, attrs));
} }
ast::ExprMatch(ref expr, ref arms) => { ast::ExprKind::Match(ref expr, ref arms) => {
try!(self.cbox(INDENT_UNIT)); try!(self.cbox(INDENT_UNIT));
try!(self.ibox(4)); try!(self.ibox(4));
try!(self.word_nbsp("match")); try!(self.word_nbsp("match"));
@ -2101,7 +2101,7 @@ impl<'a> State<'a> {
} }
try!(self.bclose_(expr.span, INDENT_UNIT)); try!(self.bclose_(expr.span, INDENT_UNIT));
} }
ast::ExprClosure(capture_clause, ref decl, ref body) => { ast::ExprKind::Closure(capture_clause, ref decl, ref body) => {
try!(self.print_capture_clause(capture_clause)); try!(self.print_capture_clause(capture_clause));
try!(self.print_fn_block_args(&**decl)); try!(self.print_fn_block_args(&**decl));
@ -2118,7 +2118,7 @@ impl<'a> State<'a> {
// we extract the block, so as not to create another set of boxes // we extract the block, so as not to create another set of boxes
let i_expr = body.expr.as_ref().unwrap(); let i_expr = body.expr.as_ref().unwrap();
match i_expr.node { match i_expr.node {
ast::ExprBlock(ref blk) => { ast::ExprKind::Block(ref blk) => {
try!(self.print_block_unclosed_with_attrs( try!(self.print_block_unclosed_with_attrs(
&**blk, &**blk,
i_expr.attrs.as_attr_slice())); i_expr.attrs.as_attr_slice()));
@ -2135,43 +2135,43 @@ impl<'a> State<'a> {
// empty box to satisfy the close. // empty box to satisfy the close.
try!(self.ibox(0)); try!(self.ibox(0));
} }
ast::ExprBlock(ref blk) => { ast::ExprKind::Block(ref blk) => {
// containing cbox, will be closed by print-block at } // containing cbox, will be closed by print-block at }
try!(self.cbox(INDENT_UNIT)); try!(self.cbox(INDENT_UNIT));
// head-box, will be closed by print-block after { // head-box, will be closed by print-block after {
try!(self.ibox(0)); try!(self.ibox(0));
try!(self.print_block_with_attrs(&**blk, attrs)); try!(self.print_block_with_attrs(&**blk, attrs));
} }
ast::ExprAssign(ref lhs, ref rhs) => { ast::ExprKind::Assign(ref lhs, ref rhs) => {
try!(self.print_expr(&**lhs)); try!(self.print_expr(&**lhs));
try!(space(&mut self.s)); try!(space(&mut self.s));
try!(self.word_space("=")); try!(self.word_space("="));
try!(self.print_expr(&**rhs)); try!(self.print_expr(&**rhs));
} }
ast::ExprAssignOp(op, ref lhs, ref rhs) => { ast::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
try!(self.print_expr(&**lhs)); try!(self.print_expr(&**lhs));
try!(space(&mut self.s)); try!(space(&mut self.s));
try!(word(&mut self.s, op.node.to_string())); try!(word(&mut self.s, op.node.to_string()));
try!(self.word_space("=")); try!(self.word_space("="));
try!(self.print_expr(&**rhs)); try!(self.print_expr(&**rhs));
} }
ast::ExprField(ref expr, id) => { ast::ExprKind::Field(ref expr, id) => {
try!(self.print_expr(&**expr)); try!(self.print_expr(&**expr));
try!(word(&mut self.s, ".")); try!(word(&mut self.s, "."));
try!(self.print_ident(id.node)); try!(self.print_ident(id.node));
} }
ast::ExprTupField(ref expr, id) => { ast::ExprKind::TupField(ref expr, id) => {
try!(self.print_expr(&**expr)); try!(self.print_expr(&**expr));
try!(word(&mut self.s, ".")); try!(word(&mut self.s, "."));
try!(self.print_usize(id.node)); try!(self.print_usize(id.node));
} }
ast::ExprIndex(ref expr, ref index) => { ast::ExprKind::Index(ref expr, ref index) => {
try!(self.print_expr(&**expr)); try!(self.print_expr(&**expr));
try!(word(&mut self.s, "[")); try!(word(&mut self.s, "["));
try!(self.print_expr(&**index)); try!(self.print_expr(&**index));
try!(word(&mut self.s, "]")); try!(word(&mut self.s, "]"));
} }
ast::ExprRange(ref start, ref end) => { ast::ExprKind::Range(ref start, ref end) => {
if let &Some(ref e) = start { if let &Some(ref e) = start {
try!(self.print_expr(&**e)); try!(self.print_expr(&**e));
} }
@ -2180,13 +2180,13 @@ impl<'a> State<'a> {
try!(self.print_expr(&**e)); try!(self.print_expr(&**e));
} }
} }
ast::ExprPath(None, ref path) => { ast::ExprKind::Path(None, ref path) => {
try!(self.print_path(path, true, 0)) try!(self.print_path(path, true, 0))
} }
ast::ExprPath(Some(ref qself), ref path) => { ast::ExprKind::Path(Some(ref qself), ref path) => {
try!(self.print_qpath(path, qself, true)) try!(self.print_qpath(path, qself, true))
} }
ast::ExprBreak(opt_ident) => { ast::ExprKind::Break(opt_ident) => {
try!(word(&mut self.s, "break")); try!(word(&mut self.s, "break"));
try!(space(&mut self.s)); try!(space(&mut self.s));
if let Some(ident) = opt_ident { if let Some(ident) = opt_ident {
@ -2194,7 +2194,7 @@ impl<'a> State<'a> {
try!(space(&mut self.s)); try!(space(&mut self.s));
} }
} }
ast::ExprAgain(opt_ident) => { ast::ExprKind::Again(opt_ident) => {
try!(word(&mut self.s, "continue")); try!(word(&mut self.s, "continue"));
try!(space(&mut self.s)); try!(space(&mut self.s));
if let Some(ident) = opt_ident { if let Some(ident) = opt_ident {
@ -2202,7 +2202,7 @@ impl<'a> State<'a> {
try!(space(&mut self.s)) try!(space(&mut self.s))
} }
} }
ast::ExprRet(ref result) => { ast::ExprKind::Ret(ref result) => {
try!(word(&mut self.s, "return")); try!(word(&mut self.s, "return"));
match *result { match *result {
Some(ref expr) => { Some(ref expr) => {
@ -2212,7 +2212,7 @@ impl<'a> State<'a> {
_ => () _ => ()
} }
} }
ast::ExprInlineAsm(ref a) => { ast::ExprKind::InlineAsm(ref a) => {
try!(word(&mut self.s, "asm!")); try!(word(&mut self.s, "asm!"));
try!(self.popen()); try!(self.popen());
try!(self.print_string(&a.asm, a.asm_str_style)); try!(self.print_string(&a.asm, a.asm_str_style));
@ -2275,8 +2275,8 @@ impl<'a> State<'a> {
try!(self.pclose()); try!(self.pclose());
} }
ast::ExprMac(ref m) => try!(self.print_mac(m, token::Paren)), ast::ExprKind::Mac(ref m) => try!(self.print_mac(m, token::Paren)),
ast::ExprParen(ref e) => { ast::ExprKind::Paren(ref e) => {
try!(self.popen()); try!(self.popen());
try!(self.print_inner_attributes_inline(attrs)); try!(self.print_inner_attributes_inline(attrs));
try!(self.print_expr(&**e)); try!(self.print_expr(&**e));
@ -2605,7 +2605,7 @@ impl<'a> State<'a> {
try!(self.word_space("=>")); try!(self.word_space("=>"));
match arm.body.node { match arm.body.node {
ast::ExprBlock(ref blk) => { ast::ExprKind::Block(ref blk) => {
// the block will close the pattern's ibox // the block will close the pattern's ibox
try!(self.print_block_unclosed_indent(&**blk, INDENT_UNIT)); try!(self.print_block_unclosed_indent(&**blk, INDENT_UNIT));

2
src/libsyntax/ptr.rs
View file

@ -17,7 +17,7 @@
//! //!
//! * **Identity**: sharing AST nodes is problematic for the various analysis //! * **Identity**: sharing AST nodes is problematic for the various analysis
//! passes (e.g. one may be able to bypass the borrow checker with a shared //! passes (e.g. one may be able to bypass the borrow checker with a shared
//! `ExprAddrOf` node taking a mutable borrow). The only reason `@T` in the //! `ExprKind::AddrOf` node taking a mutable borrow). The only reason `@T` in the
//! AST hasn't caused issues is because of inefficient folding passes which //! AST hasn't caused issues is because of inefficient folding passes which
//! would always deduplicate any such shared nodes. Even if the AST were to //! would always deduplicate any such shared nodes. Even if the AST were to
//! switch to an arena, this would still hold, i.e. it couldn't use `&'a T`, //! switch to an arena, this would still hold, i.e. it couldn't use `&'a T`,

4
src/libsyntax/test.rs
View file

@ -613,10 +613,10 @@ fn mk_test_descs(cx: &TestCtxt) -> P<ast::Expr> {
P(ast::Expr { P(ast::Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ExprAddrOf(ast::MutImmutable, node: ast::ExprKind::AddrOf(ast::MutImmutable,
P(ast::Expr { P(ast::Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ExprVec(cx.testfns.iter().map(|test| { node: ast::ExprKind::Vec(cx.testfns.iter().map(|test| {
mk_test_desc_and_fn_rec(cx, test) mk_test_desc_and_fn_rec(cx, test)
}).collect()), }).collect()),
span: DUMMY_SP, span: DUMMY_SP,

66
src/libsyntax/visit.rs
View file

@ -651,21 +651,21 @@ pub fn walk_mac<'v, V: Visitor<'v>>(_: &mut V, _: &'v Mac) {
pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) { pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
match expression.node { match expression.node {
ExprBox(ref subexpression) => { ExprKind::Box(ref subexpression) => {
visitor.visit_expr(subexpression) visitor.visit_expr(subexpression)
} }
ExprInPlace(ref place, ref subexpression) => { ExprKind::InPlace(ref place, ref subexpression) => {
visitor.visit_expr(place); visitor.visit_expr(place);
visitor.visit_expr(subexpression) visitor.visit_expr(subexpression)
} }
ExprVec(ref subexpressions) => { ExprKind::Vec(ref subexpressions) => {
walk_list!(visitor, visit_expr, subexpressions); walk_list!(visitor, visit_expr, subexpressions);
} }
ExprRepeat(ref element, ref count) => { ExprKind::Repeat(ref element, ref count) => {
visitor.visit_expr(element); visitor.visit_expr(element);
visitor.visit_expr(count) visitor.visit_expr(count)
} }
ExprStruct(ref path, ref fields, ref optional_base) => { ExprKind::Struct(ref path, ref fields, ref optional_base) => {
visitor.visit_path(path, expression.id); visitor.visit_path(path, expression.id);
for field in fields { for field in fields {
visitor.visit_ident(field.ident.span, field.ident.node); visitor.visit_ident(field.ident.span, field.ident.node);
@ -673,116 +673,116 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
} }
walk_list!(visitor, visit_expr, optional_base); walk_list!(visitor, visit_expr, optional_base);
} }
ExprTup(ref subexpressions) => { ExprKind::Tup(ref subexpressions) => {
walk_list!(visitor, visit_expr, subexpressions); walk_list!(visitor, visit_expr, subexpressions);
} }
ExprCall(ref callee_expression, ref arguments) => { ExprKind::Call(ref callee_expression, ref arguments) => {
walk_list!(visitor, visit_expr, arguments); walk_list!(visitor, visit_expr, arguments);
visitor.visit_expr(callee_expression) visitor.visit_expr(callee_expression)
} }
ExprMethodCall(ref ident, ref types, ref arguments) => { ExprKind::MethodCall(ref ident, ref types, ref arguments) => {
visitor.visit_ident(ident.span, ident.node); visitor.visit_ident(ident.span, ident.node);
walk_list!(visitor, visit_expr, arguments); walk_list!(visitor, visit_expr, arguments);
walk_list!(visitor, visit_ty, types); walk_list!(visitor, visit_ty, types);
} }
ExprBinary(_, ref left_expression, ref right_expression) => { ExprKind::Binary(_, ref left_expression, ref right_expression) => {
visitor.visit_expr(left_expression); visitor.visit_expr(left_expression);
visitor.visit_expr(right_expression) visitor.visit_expr(right_expression)
} }
ExprAddrOf(_, ref subexpression) | ExprUnary(_, ref subexpression) => { ExprKind::AddrOf(_, ref subexpression) | ExprKind::Unary(_, ref subexpression) => {
visitor.visit_expr(subexpression) visitor.visit_expr(subexpression)
} }
ExprLit(_) => {} ExprKind::Lit(_) => {}
ExprCast(ref subexpression, ref typ) | ExprType(ref subexpression, ref typ) => { ExprKind::Cast(ref subexpression, ref typ) | ExprKind::Type(ref subexpression, ref typ) => {
visitor.visit_expr(subexpression); visitor.visit_expr(subexpression);
visitor.visit_ty(typ) visitor.visit_ty(typ)
} }
ExprIf(ref head_expression, ref if_block, ref optional_else) => { ExprKind::If(ref head_expression, ref if_block, ref optional_else) => {
visitor.visit_expr(head_expression); visitor.visit_expr(head_expression);
visitor.visit_block(if_block); visitor.visit_block(if_block);
walk_list!(visitor, visit_expr, optional_else); walk_list!(visitor, visit_expr, optional_else);
} }
ExprWhile(ref subexpression, ref block, opt_ident) => { ExprKind::While(ref subexpression, ref block, opt_ident) => {
visitor.visit_expr(subexpression); visitor.visit_expr(subexpression);
visitor.visit_block(block); visitor.visit_block(block);
walk_opt_ident(visitor, expression.span, opt_ident) walk_opt_ident(visitor, expression.span, opt_ident)
} }
ExprIfLet(ref pattern, ref subexpression, ref if_block, ref optional_else) => { ExprKind::IfLet(ref pattern, ref subexpression, ref if_block, ref optional_else) => {
visitor.visit_pat(pattern); visitor.visit_pat(pattern);
visitor.visit_expr(subexpression); visitor.visit_expr(subexpression);
visitor.visit_block(if_block); visitor.visit_block(if_block);
walk_list!(visitor, visit_expr, optional_else); walk_list!(visitor, visit_expr, optional_else);
} }
ExprWhileLet(ref pattern, ref subexpression, ref block, opt_ident) => { ExprKind::WhileLet(ref pattern, ref subexpression, ref block, opt_ident) => {
visitor.visit_pat(pattern); visitor.visit_pat(pattern);
visitor.visit_expr(subexpression); visitor.visit_expr(subexpression);
visitor.visit_block(block); visitor.visit_block(block);
walk_opt_ident(visitor, expression.span, opt_ident) walk_opt_ident(visitor, expression.span, opt_ident)
} }
ExprForLoop(ref pattern, ref subexpression, ref block, opt_ident) => { ExprKind::ForLoop(ref pattern, ref subexpression, ref block, opt_ident) => {
visitor.visit_pat(pattern); visitor.visit_pat(pattern);
visitor.visit_expr(subexpression); visitor.visit_expr(subexpression);
visitor.visit_block(block); visitor.visit_block(block);
walk_opt_ident(visitor, expression.span, opt_ident) walk_opt_ident(visitor, expression.span, opt_ident)
} }
ExprLoop(ref block, opt_ident) => { ExprKind::Loop(ref block, opt_ident) => {
visitor.visit_block(block); visitor.visit_block(block);
walk_opt_ident(visitor, expression.span, opt_ident) walk_opt_ident(visitor, expression.span, opt_ident)
} }
ExprMatch(ref subexpression, ref arms) => { ExprKind::Match(ref subexpression, ref arms) => {
visitor.visit_expr(subexpression); visitor.visit_expr(subexpression);
walk_list!(visitor, visit_arm, arms); walk_list!(visitor, visit_arm, arms);
} }
ExprClosure(_, ref function_declaration, ref body) => { ExprKind::Closure(_, ref function_declaration, ref body) => {
visitor.visit_fn(FnKind::Closure, visitor.visit_fn(FnKind::Closure,
function_declaration, function_declaration,
body, body,
expression.span, expression.span,
expression.id) expression.id)
} }
ExprBlock(ref block) => visitor.visit_block(block), ExprKind::Block(ref block) => visitor.visit_block(block),
ExprAssign(ref left_hand_expression, ref right_hand_expression) => { ExprKind::Assign(ref left_hand_expression, ref right_hand_expression) => {
visitor.visit_expr(right_hand_expression); visitor.visit_expr(right_hand_expression);
visitor.visit_expr(left_hand_expression) visitor.visit_expr(left_hand_expression)
} }
ExprAssignOp(_, ref left_expression, ref right_expression) => { ExprKind::AssignOp(_, ref left_expression, ref right_expression) => {
visitor.visit_expr(right_expression); visitor.visit_expr(right_expression);
visitor.visit_expr(left_expression) visitor.visit_expr(left_expression)
} }
ExprField(ref subexpression, ref ident) => { ExprKind::Field(ref subexpression, ref ident) => {
visitor.visit_expr(subexpression); visitor.visit_expr(subexpression);
visitor.visit_ident(ident.span, ident.node); visitor.visit_ident(ident.span, ident.node);
} }
ExprTupField(ref subexpression, _) => { ExprKind::TupField(ref subexpression, _) => {
visitor.visit_expr(subexpression); visitor.visit_expr(subexpression);
} }
ExprIndex(ref main_expression, ref index_expression) => { ExprKind::Index(ref main_expression, ref index_expression) => {
visitor.visit_expr(main_expression); visitor.visit_expr(main_expression);
visitor.visit_expr(index_expression) visitor.visit_expr(index_expression)
} }
ExprRange(ref start, ref end) => { ExprKind::Range(ref start, ref end) => {
walk_list!(visitor, visit_expr, start); walk_list!(visitor, visit_expr, start);
walk_list!(visitor, visit_expr, end); walk_list!(visitor, visit_expr, end);
} }
ExprPath(ref maybe_qself, ref path) => { ExprKind::Path(ref maybe_qself, ref path) => {
if let Some(ref qself) = *maybe_qself { if let Some(ref qself) = *maybe_qself {
visitor.visit_ty(&qself.ty); visitor.visit_ty(&qself.ty);
} }
visitor.visit_path(path, expression.id) visitor.visit_path(path, expression.id)
} }
ExprBreak(ref opt_sp_ident) | ExprAgain(ref opt_sp_ident) => { ExprKind::Break(ref opt_sp_ident) | ExprKind::Again(ref opt_sp_ident) => {
for sp_ident in opt_sp_ident { for sp_ident in opt_sp_ident {
visitor.visit_ident(sp_ident.span, sp_ident.node); visitor.visit_ident(sp_ident.span, sp_ident.node);
} }
} }
ExprRet(ref optional_expression) => { ExprKind::Ret(ref optional_expression) => {
walk_list!(visitor, visit_expr, optional_expression); walk_list!(visitor, visit_expr, optional_expression);
} }
ExprMac(ref mac) => visitor.visit_mac(mac), ExprKind::Mac(ref mac) => visitor.visit_mac(mac),
ExprParen(ref subexpression) => { ExprKind::Paren(ref subexpression) => {
visitor.visit_expr(subexpression) visitor.visit_expr(subexpression)
} }
ExprInlineAsm(ref ia) => { ExprKind::InlineAsm(ref ia) => {
for &(_, ref input) in &ia.inputs { for &(_, ref input) in &ia.inputs {
visitor.visit_expr(&input) visitor.visit_expr(&input)
} }

2
src/libsyntax_ext/asm.rs
View file

@ -247,7 +247,7 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
MacEager::expr(P(ast::Expr { MacEager::expr(P(ast::Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ExprInlineAsm(ast::InlineAsm { node: ast::ExprKind::InlineAsm(ast::InlineAsm {
asm: token::intern_and_get_ident(&asm), asm: token::intern_and_get_ident(&asm),
asm_str_style: asm_str_style.unwrap(), asm_str_style: asm_str_style.unwrap(),
outputs: outputs, outputs: outputs,

2
src/libsyntax_ext/concat.rs
View file

@ -27,7 +27,7 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt,
let mut accumulator = String::new(); let mut accumulator = String::new();
for e in es { for e in es {
match e.node { match e.node {
ast::ExprLit(ref lit) => { ast::ExprKind::Lit(ref lit) => {
match lit.node { match lit.node {
ast::LitStr(ref s, _) | ast::LitStr(ref s, _) |
ast::LitFloat(ref s, _) | ast::LitFloat(ref s, _) |

2
src/libsyntax_ext/concat_idents.rs
View file

@ -54,7 +54,7 @@ pub fn expand_syntax_ext<'cx>(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree])
let e = P(ast::Expr { let e = P(ast::Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(None, node: ast::ExprKind::Path(None,
ast::Path { ast::Path {
span: sp, span: sp,
global: false, global: false,

16
src/libsyntax_ext/deriving/encodable.rs
View file

@ -91,7 +91,7 @@
use deriving::generic::*; use deriving::generic::*;
use deriving::generic::ty::*; use deriving::generic::ty::*;
use syntax::ast::{MetaItem, Expr, ExprRet, MutMutable}; use syntax::ast::{MetaItem, Expr, ExprKind, MutMutable};
use syntax::codemap::Span; use syntax::codemap::Span;
use syntax::ext::base::{ExtCtxt,Annotatable}; use syntax::ext::base::{ExtCtxt,Annotatable};
use syntax::ext::build::AstBuilder; use syntax::ext::build::AstBuilder;
@ -208,16 +208,15 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
let call = if i != last { let call = if i != last {
cx.expr_try(span, call) cx.expr_try(span, call)
} else { } else {
cx.expr(span, ExprRet(Some(call))) cx.expr(span, ExprKind::Ret(Some(call)))
}; };
stmts.push(cx.stmt_expr(call)); stmts.push(cx.stmt_expr(call));
} }
// unit structs have no fields and need to return Ok() // unit structs have no fields and need to return Ok()
if stmts.is_empty() { if stmts.is_empty() {
let ret_ok = cx.expr(trait_span, let ok = cx.expr_ok(trait_span, cx.expr_tuple(trait_span, vec![]));
ExprRet(Some(cx.expr_ok(trait_span, let ret_ok = cx.expr(trait_span, ExprKind::Ret(Some(ok)));
cx.expr_tuple(trait_span, vec![])))));
stmts.push(cx.stmt_expr(ret_ok)); stmts.push(cx.stmt_expr(ret_ok));
} }
@ -254,14 +253,13 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
let call = if i != last { let call = if i != last {
cx.expr_try(span, call) cx.expr_try(span, call)
} else { } else {
cx.expr(span, ExprRet(Some(call))) cx.expr(span, ExprKind::Ret(Some(call)))
}; };
stmts.push(cx.stmt_expr(call)); stmts.push(cx.stmt_expr(call));
} }
} else { } else {
let ret_ok = cx.expr(trait_span, let ok = cx.expr_ok(trait_span, cx.expr_tuple(trait_span, vec![]));
ExprRet(Some(cx.expr_ok(trait_span, let ret_ok = cx.expr(trait_span, ExprKind::Ret(Some(ok)));
cx.expr_tuple(trait_span, vec![])))));
stmts.push(cx.stmt_expr(ret_ok)); stmts.push(cx.stmt_expr(ret_ok));
} }

8
src/libsyntax_ext/deriving/generic/mod.rs
View file

@ -1311,7 +1311,7 @@ impl<'a> MethodDef<'a> {
// expression; here add a layer of borrowing, turning // expression; here add a layer of borrowing, turning
// `(*self, *__arg_0, ...)` into `(&*self, &*__arg_0, ...)`. // `(*self, *__arg_0, ...)` into `(&*self, &*__arg_0, ...)`.
let borrowed_self_args = self_args.move_map(|self_arg| cx.expr_addr_of(sp, self_arg)); let borrowed_self_args = self_args.move_map(|self_arg| cx.expr_addr_of(sp, self_arg));
let match_arg = cx.expr(sp, ast::ExprTup(borrowed_self_args)); let match_arg = cx.expr(sp, ast::ExprKind::Tup(borrowed_self_args));
//Lastly we create an expression which branches on all discriminants being equal //Lastly we create an expression which branches on all discriminants being equal
// if discriminant_test { // if discriminant_test {
@ -1389,7 +1389,7 @@ impl<'a> MethodDef<'a> {
// expression; here add a layer of borrowing, turning // expression; here add a layer of borrowing, turning
// `(*self, *__arg_0, ...)` into `(&*self, &*__arg_0, ...)`. // `(*self, *__arg_0, ...)` into `(&*self, &*__arg_0, ...)`.
let borrowed_self_args = self_args.move_map(|self_arg| cx.expr_addr_of(sp, self_arg)); let borrowed_self_args = self_args.move_map(|self_arg| cx.expr_addr_of(sp, self_arg));
let match_arg = cx.expr(sp, ast::ExprTup(borrowed_self_args)); let match_arg = cx.expr(sp, ast::ExprKind::Tup(borrowed_self_args));
cx.expr_match(sp, match_arg, match_arms) cx.expr_match(sp, match_arg, match_arms)
} }
} }
@ -1509,8 +1509,8 @@ impl<'a> TraitDef<'a> {
}; };
let ident = cx.ident_of(&format!("{}_{}", prefix, i)); let ident = cx.ident_of(&format!("{}_{}", prefix, i));
paths.push(codemap::Spanned{span: sp, node: ident}); paths.push(codemap::Spanned{span: sp, node: ident});
let val = cx.expr( let val = cx.expr_deref(sp, cx.expr_path(cx.path_ident(sp,ident)));
sp, ast::ExprParen(cx.expr_deref(sp, cx.expr_path(cx.path_ident(sp,ident))))); let val = cx.expr(sp, ast::ExprKind::Paren(val));
ident_expr.push((sp, opt_id, val, &struct_field.node.attrs[..])); ident_expr.push((sp, opt_id, val, &struct_field.node.attrs[..]));
} }

2
src/libsyntax_ext/format.rs
View file

@ -559,7 +559,7 @@ impl<'a, 'b> Context<'a, 'b> {
// as series of let's; the first approach does. // as series of let's; the first approach does.
let pat = self.ecx.pat_tuple(self.fmtsp, pats); let pat = self.ecx.pat_tuple(self.fmtsp, pats);
let arm = self.ecx.arm(self.fmtsp, vec!(pat), args_array); let arm = self.ecx.arm(self.fmtsp, vec!(pat), args_array);
let head = self.ecx.expr(self.fmtsp, ast::ExprTup(heads)); let head = self.ecx.expr(self.fmtsp, ast::ExprKind::Tup(heads));
let result = self.ecx.expr_match(self.fmtsp, head, vec!(arm)); let result = self.ecx.expr_match(self.fmtsp, head, vec!(arm));
let args_slice = self.ecx.expr_addr_of(self.fmtsp, result); let args_slice = self.ecx.expr_addr_of(self.fmtsp, result);