let empty_block = expr_to_block(BlockCheckMode::Default, None);
let loop_expr = P(ast::Expr {
- node: ast::ExprLoop(empty_block, None),
+ node: ast::ExprKind::Loop(empty_block, None),
id: ast::DUMMY_NODE_ID,
span: codemap::DUMMY_SP,
attrs: None,
// }
//
// But for now there are type-inference issues doing that.
- ExprBox(ref e) => {
+ ExprKind::Box(ref e) => {
hir::ExprBox(lower_expr(lctx, e))
}
// Desugar ExprBox: `in (PLACE) EXPR`
- ExprInPlace(ref placer, ref value_expr) => {
+ ExprKind::InPlace(ref placer, ref value_expr) => {
// to:
//
// let p = PLACE;
});
}
- ExprVec(ref exprs) => {
+ ExprKind::Vec(ref exprs) => {
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 count = lower_expr(lctx, count);
hir::ExprRepeat(expr, count)
}
- ExprTup(ref elts) => {
+ ExprKind::Tup(ref elts) => {
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);
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 args = args.iter().map(|x| lower_expr(lctx, x)).collect();
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 lhs = lower_expr(lctx, lhs);
let rhs = lower_expr(lctx, rhs);
hir::ExprBinary(binop, lhs, rhs)
}
- ExprUnary(op, ref ohs) => {
+ ExprKind::Unary(op, ref ohs) => {
let op = lower_unop(lctx, op);
let ohs = lower_expr(lctx, ohs);
hir::ExprUnary(op, ohs)
}
- ExprLit(ref l) => hir::ExprLit(P((**l).clone())),
- ExprCast(ref expr, ref ty) => {
+ ExprKind::Lit(ref l) => hir::ExprLit(P((**l).clone())),
+ ExprKind::Cast(ref expr, ref ty) => {
let expr = lower_expr(lctx, expr);
hir::ExprCast(expr, lower_ty(lctx, ty))
}
- ExprType(ref expr, ref ty) => {
+ ExprKind::Type(ref expr, ref ty) => {
let expr = lower_expr(lctx, expr);
hir::ExprType(expr, lower_ty(lctx, ty))
}
- ExprAddrOf(m, ref ohs) => {
+ ExprKind::AddrOf(m, ref ohs) => {
let m = lower_mutability(lctx, m);
let ohs = lower_expr(lctx, ohs);
hir::ExprAddrOf(m, ohs)
}
// More complicated than you might expect because the else branch
// 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| {
match els.node {
- ExprIfLet(..) => {
+ ExprKind::IfLet(..) => {
cache_ids(lctx, e.id, |lctx| {
// wrap the if-let expr in a block
let span = els.span;
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),
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),
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),
arms.iter().map(|x| lower_arm(lctx, x)).collect(),
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),
lower_fn_decl(lctx, decl),
lower_block(lctx, body))
}
- ExprBlock(ref blk) => hir::ExprBlock(lower_block(lctx, blk)),
- ExprAssign(ref el, ref er) => {
+ ExprKind::Block(ref blk) => hir::ExprBlock(lower_block(lctx, blk)),
+ ExprKind::Assign(ref el, ref 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),
lower_expr(lctx, el),
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))
}
- ExprTupField(ref el, ident) => {
+ ExprKind::TupField(ref 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))
}
- ExprRange(ref e1, ref e2) => {
+ ExprKind::Range(ref e1, ref e2) => {
hir::ExprRange(e1.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 }| {
hir::QSelf {
ty: lower_ty(lctx, ty),
});
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))
})),
- 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))
})),
- ExprRet(ref e) => hir::ExprRet(e.as_ref().map(|x| lower_expr(lctx, x))),
- ExprInlineAsm(InlineAsm {
+ ExprKind::Ret(ref e) => hir::ExprRet(e.as_ref().map(|x| lower_expr(lctx, x))),
+ ExprKind::InlineAsm(InlineAsm {
ref inputs,
ref outputs,
ref asm,
dialect: dialect,
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),
fields.iter().map(|x| lower_field(lctx, x)).collect(),
maybe_expr.as_ref().map(|x| lower_expr(lctx, x)))
}
- ExprParen(ref ex) => {
+ ExprKind::Paren(ref ex) => {
// merge attributes into the inner expression.
return lower_expr(lctx, ex).map(|mut ex| {
ex.attrs.update(|attrs| {
// Desugar ExprIfLet
// 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:
//
// match <sub_expr> {
// Desugar ExprWhileLet
// 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:
//
// [opt_ident]: loop {
// Desugar ExprForLoop
// 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:
//
// {
});
}
- ExprMac(_) => panic!("Shouldn't exist here"),
+ ExprKind::Mac(_) => panic!("Shouldn't exist here"),
},
span: e.span,
attrs: e.attrs.clone(),
impl UnusedParens {
fn check_unused_parens_core(&self, cx: &EarlyContext, value: &ast::Expr, msg: &str,
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);
if !necessary {
cx.span_lint(UNUSED_PARENS, value.span,
/// y: 1 }) == foo` does not.
fn contains_exterior_struct_lit(value: &ast::Expr) -> bool {
match value.node {
- ast::ExprStruct(..) => true,
+ ast::ExprKind::Struct(..) => true,
- ast::ExprAssign(ref lhs, ref rhs) |
- ast::ExprAssignOp(_, ref lhs, ref rhs) |
- ast::ExprBinary(_, ref lhs, ref rhs) => {
+ ast::ExprKind::Assign(ref lhs, ref rhs) |
+ ast::ExprKind::AssignOp(_, ref lhs, ref rhs) |
+ ast::ExprKind::Binary(_, ref lhs, ref rhs) => {
// X { y: 1 } + X { y: 2 }
contains_exterior_struct_lit(&**lhs) ||
contains_exterior_struct_lit(&**rhs)
}
- ast::ExprUnary(_, ref x) |
- ast::ExprCast(ref x, _) |
- ast::ExprType(ref x, _) |
- ast::ExprField(ref x, _) |
- ast::ExprTupField(ref x, _) |
- ast::ExprIndex(ref x, _) => {
+ ast::ExprKind::Unary(_, ref x) |
+ ast::ExprKind::Cast(ref x, _) |
+ ast::ExprKind::Type(ref x, _) |
+ ast::ExprKind::Field(ref x, _) |
+ ast::ExprKind::TupField(ref x, _) |
+ ast::ExprKind::Index(ref x, _) => {
// &X { y: 1 }, X { y: 1 }.y
contains_exterior_struct_lit(&**x)
}
- ast::ExprMethodCall(_, _, ref exprs) => {
+ ast::ExprKind::MethodCall(_, _, ref exprs) => {
// X { y: 1 }.bar(...)
contains_exterior_struct_lit(&*exprs[0])
}
impl EarlyLintPass for UnusedParens {
fn check_expr(&mut self, cx: &EarlyContext, e: &ast::Expr) {
+ use syntax::ast::ExprKind::*;
let (value, msg, struct_lit_needs_parens) = match e.node {
- ast::ExprIf(ref cond, _, _) => (cond, "`if` condition", true),
- ast::ExprWhile(ref cond, _, _) => (cond, "`while` condition", true),
- ast::ExprIfLet(_, ref cond, _, _) => (cond, "`if let` head expression", true),
- ast::ExprWhileLet(_, ref cond, _, _) => (cond, "`while let` head expression", true),
- ast::ExprForLoop(_, ref cond, _, _) => (cond, "`for` head expression", true),
- ast::ExprMatch(ref head, _) => (head, "`match` head expression", true),
- ast::ExprRet(Some(ref value)) => (value, "`return` value", false),
- ast::ExprAssign(_, ref value) => (value, "assigned value", false),
- ast::ExprAssignOp(_, _, ref value) => (value, "assigned value", false),
- ast::ExprInPlace(_, ref value) => (value, "emplacement value", false),
+ If(ref cond, _, _) => (cond, "`if` condition", true),
+ While(ref cond, _, _) => (cond, "`while` condition", true),
+ IfLet(_, ref cond, _, _) => (cond, "`if let` head expression", true),
+ WhileLet(_, ref cond, _, _) => (cond, "`while let` head expression", true),
+ ForLoop(_, ref cond, _, _) => (cond, "`for` head expression", true),
+ Match(ref head, _) => (head, "`match` head expression", true),
+ Ret(Some(ref value)) => (value, "`return` value", false),
+ Assign(_, ref value) => (value, "assigned value", false),
+ AssignOp(_, _, ref value) => (value, "assigned value", false),
+ InPlace(_, ref value) => (value, "emplacement value", false),
_ => return
};
self.check_unused_parens_core(cx, &**value, msg, struct_lit_needs_parens);
CheckConstFn{ sess: self.sess}.visit_block(block);
}
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);
} else {
visit::walk_expr(self, e);
impl<'a, 'v> Visitor<'v> for CheckNoAsm<'a> {
fn visit_expr(&mut self, e: &ast::Expr) {
match e.node {
- ast::ExprInlineAsm(_) => span_err!(self.sess, e.span, E0472,
- "asm! is unsupported on this target"),
+ ast::ExprKind::InlineAsm(_) => span_err!(self.sess, e.span, E0472,
+ "asm! is unsupported on this target"),
_ => {},
}
visit::walk_expr(self, e)
fn visit_expr(&mut self, ex: &ast::Expr) {
self.process_macro_use(ex.span, ex.id);
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,
// because just walking the callee path does what we want.
visit::walk_expr(self, ex);
}
- ast::ExprPath(_, ref path) => {
+ ast::ExprKind::Path(_, ref path) => {
self.process_path(ex.id, path, None);
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 adt = self.tcx.expr_ty(&hir_expr).ty_adt_def().unwrap();
let def = self.tcx.resolve_expr(&hir_expr);
self.process_struct_lit(ex, path, fields, adt.variant_of_def(def), base)
}
- ast::ExprMethodCall(_, _, ref args) => self.process_method_call(ex, args),
- ast::ExprField(ref sub_ex, _) => {
+ ast::ExprKind::MethodCall(_, _, ref args) => self.process_method_call(ex, args),
+ ast::ExprKind::Field(ref sub_ex, _) => {
self.visit_expr(&sub_ex);
if let Some(field_data) = self.save_ctxt.get_expr_data(ex) {
field_data.scope);
}
}
- ast::ExprTupField(ref sub_ex, idx) => {
+ ast::ExprKind::TupField(ref sub_ex, idx) => {
self.visit_expr(&**sub_ex);
let hir_node = lower_expr(self.save_ctxt.lcx, sub_ex);
ty)),
}
}
- ast::ExprClosure(_, ref decl, ref body) => {
+ ast::ExprKind::Closure(_, ref decl, ref body) => {
let mut id = String::from("$");
id.push_str(&ex.id.to_string());
self.process_formals(&decl.inputs, &id);
// walk the body
self.nest(ex.id, |v| v.visit_block(&**body));
}
- ast::ExprForLoop(ref pattern, ref subexpression, ref block, _) |
- ast::ExprWhileLet(ref pattern, ref subexpression, ref block, _) => {
+ ast::ExprKind::ForLoop(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));
self.process_var_decl(pattern, value);
visit::walk_expr(self, subexpression);
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));
self.process_var_decl(pattern, value);
visit::walk_expr(self, subexpression);
return None;
}
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);
match self.tcx.expr_ty_adjusted(&hir_node).sty {
ty::TyStruct(def, _) => {
}
}
}
- ast::ExprStruct(ref path, _, _) => {
+ ast::ExprKind::Struct(ref path, _, _) => {
let hir_node = lowering::lower_expr(self.lcx, expr);
match self.tcx.expr_ty_adjusted(&hir_node).sty {
ty::TyStruct(def, _) => {
}
}
}
- ast::ExprMethodCall(..) => {
+ ast::ExprKind::MethodCall(..) => {
let method_call = ty::MethodCall::expr(expr.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() {
decl_id: decl_id,
}))
}
- ast::ExprPath(_, ref path) => {
+ ast::ExprKind::Path(_, ref path) => {
self.get_path_data(expr.id, path)
}
_ => {
// The Rust abstract syntax tree.
-pub use self::Expr_::*;
pub use self::FloatTy::*;
pub use self::ForeignItem_::*;
pub use self::IntTy::*;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash,)]
pub struct Expr {
pub id: NodeId,
- pub node: Expr_,
+ pub node: ExprKind,
pub span: Span,
pub attrs: ThinAttributes
}
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum Expr_ {
+pub enum ExprKind {
/// A `box x` expression.
- ExprBox(P<Expr>),
+ Box(P<Expr>),
/// 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]`)
+ Vec(Vec<P<Expr>>),
/// A function call
///
/// The first field resolves to the function itself,
/// 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)`)
///
/// The `SpannedIdent` is the identifier for the method name.
/// and the remaining elements are the rest of the arguments.
///
/// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as
- /// `ExprMethodCall(foo, [Bar, Baz], [x, a, b, c, d])`.
-
ExprMethodCall(SpannedIdent, Vec<P<Ty>>, Vec<P<Expr>>),
+ /// `ExprKind::MethodCall(foo, [Bar, Baz], [x, a, b, c, d])`.
+ MethodCall(SpannedIdent, Vec<P<Ty>>, Vec<P<Expr>>),
/// A tuple (`(a, b, c ,d)`)
+ Tup(Vec<P<Expr>>),
/// 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`)
- ExprUnary(UnOp, P<Expr>),
+ Unary(UnOp, P<Expr>),
/// A literal (For example: `1u8`, `"foo"`)
- ExprLit(P<Lit>),
+ Lit(P<Lit>),
/// A cast (`foo as f64`)
- ExprCast(P<Expr>, P<Ty>),
- ExprType(P<Expr>, P<Ty>),
+ Cast(P<Expr>, P<Ty>),
+ Type(P<Expr>, P<Ty>),
/// An `if` block, with an optional else block
///
/// `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
///
/// `if let pat = expr { block } else { expr }`
///
/// 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
///
/// `'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
///
/// `'label: while let pat = expr { block }`
///
/// 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
///
/// `'label: for pat in expr { block }`
///
/// 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)
///
/// `'label: loop { block }`
- ExprLoop(P<Block>, Option<Ident>),
+ Loop(P<Block>, Option<Ident>),
/// A `match` block.
-
ExprMatch(P<Expr>, Vec<Arm>),
+ Match(P<Expr>, Vec<Arm>),
/// 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 (`{ ... }`)
- ExprBlock(P<Block>),
+ Block(P<Block>),
/// An assignment (`a = foo()`)
- ExprAssign(P<Expr>, P<Expr>),
+ Assign(P<Expr>, P<Expr>),
/// An assignment with an operator
///
/// For example, `a += 1`.
- ExprAssignOp(BinOp, P<Expr>, P<Expr>),
+ AssignOp(BinOp, P<Expr>, P<Expr>),
/// 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
///
/// For example, `foo.0`.
- ExprTupField(P<Expr>, Spanned<usize>),
+ TupField(P<Expr>, Spanned<usize>),
/// An indexing operation (`foo[2]`)
- ExprIndex(P<Expr>, P<Expr>),
+ Index(P<Expr>, P<Expr>),
/// 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
/// parameters, e.g. foo::bar::<baz>.
///
/// Optionally "qualified",
/// e.g. `<Vec<T> as SomeTrait>::SomeType`.
- ExprPath(Option<QSelf>, Path),
+ Path(Option<QSelf>, Path),
/// A referencing operation (`&a` or `&mut a`)
- ExprAddrOf(Mutability, P<Expr>),
+ AddrOf(Mutability, P<Expr>),
/// A `break`, with an optional label to break
- ExprBreak(Option<SpannedIdent>),
+ Break(Option<SpannedIdent>),
/// A `continue`, with an optional label
- ExprAgain(Option<SpannedIdent>),
+ Again(Option<SpannedIdent>),
/// A `return`, with an optional value to be returned
-
ExprRet(Option<P<Expr>>),
+ Ret(Option<P<Expr>>),
/// Output of the `asm!()` macro
- ExprInlineAsm(InlineAsm),
+ InlineAsm(InlineAsm),
/// A macro invocation; pre-expansion
- ExprMac(Mac),
+ Mac(Mac),
/// A struct literal expression.
///
/// For example, `Foo {x: 1, y: 2}`, or
/// `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.
///
/// For example, `[1u8; 5]`. The first expression is the element
/// 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
- ExprParen(P<Expr>)
+ Paren(P<Expr>),
}
/// The explicit Self type in a "qualified path". The actual
}
pub fn is_path(e: P<Expr>) -> bool {
- match e.node { ExprPath(..) => true, _ => false }
+ match e.node { ExprKind::Path(..) => true, _ => false }
}
fold::noop_fold_expr(ast::Expr {
id: id,
node: match node {
- ast::ExprMatch(m, arms) => {
- ast::ExprMatch(m, arms.into_iter()
+ ast::ExprKind::Match(m, arms) => {
+ ast::ExprKind::Match(m, arms.into_iter()
.filter(|a| (cx.in_cfg)(&a.attrs))
.collect())
}
return Some(p);
}
if let Some(e) = self.expr {
- if let ast::ExprLit(_) = e.node {
+ if let ast::ExprKind::Lit(_) = e.node {
return Some(P(ast::Pat {
id: ast::DUMMY_NODE_ID,
span: e.span,
pub fn raw_expr(sp: Span) -> P<ast::Expr> {
P(ast::Expr {
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,
attrs: None,
})
// we want to be able to handle e.g. concat("foo", "bar")
let expr = cx.expander().fold_expr(expr);
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)),
_ => cx.span_err(l.span, err_msg)
},
expr: Option<P<ast::Expr>>) -> P<ast::Block>;
// expressions
- fn expr(&self, span: Span, node: ast::Expr
_) -> P<ast::Expr>;
+ fn expr(&self, span: Span, node: ast::Expr
Kind) -> 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_ident(&self, span: Span, id: ast::Ident) -> P<ast::Expr>;
})
}
- fn expr(&self, span: Span, node: ast::Expr
_) -> P<ast::Expr> {
+ fn expr(&self, span: Span, node: ast::Expr
Kind) -> P<ast::Expr> {
P(ast::Expr {
id: ast::DUMMY_NODE_ID,
node: node,
}
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.
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_binary(&self, sp: Span, op: ast::BinOpKind,
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> {
self.expr_unary(sp, UnOp::Deref, e)
}
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> {
};
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> {
let field_span = 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> {
- 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> {
- 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> {
- 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,
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> ,
args: Vec<P<ast::Expr>> ) -> P<ast::Expr> {
mut args: Vec<P<ast::Expr>> ) -> P<ast::Expr> {
let id = Spanned { node: ident, span: span };
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> {
- 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 {
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> {
- self.expr(span, ast::ExprStruct(path, fields, None))
+ self.expr(span, ast::ExprKind::Struct(path, fields, None))
}
fn expr_struct_ident(&self, span: Span,
id: ast::Ident, fields: Vec<ast::Field>) -> 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> {
self.expr_lit(span, ast::LitInt(i as u64, ast::UnsignedIntLit(ast::TyUs)))
}
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> {
self.expr_call_global(sp, self.std_path(&["vec", "Vec", "new"]),
}
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))
}
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> {
- self.expr(sp, ast::ExprTup(exprs))
+ self.expr(sp, ast::ExprKind::Tup(exprs))
}
fn expr_fail(&self, span: Span, msg: InternedString) -> P<ast::Expr> {
let err_inner_expr = self.expr_call(sp, self.expr_path(err_path),
vec!(binding_expr.clone()));
// 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
let ok_arm = self.arm(sp, vec!(ok_pat), binding_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>,
then: P<ast::Expr>, els: Option<P<ast::Expr>>) -> P<ast::Expr> {
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> {
- self.expr(span, ast::ExprLoop(block, None))
+ self.expr(span, ast::ExprKind::Loop(block, None))
}
fn lambda_fn_decl(&self, span: Span,
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> {
let fn_decl = self.fn_decl(
ids.iter().map(|id| self.arg(span, *id, self.ty_infer(span))).collect(),
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> {
self.lambda(span, Vec::new(), blk)
// expr_mac should really be expr_ext or something; it's the
// entry-point for all syntax extensions.
- ast::ExprMac(mac) => {
+ ast::ExprKind::Mac(mac) => {
// Assert that we drop any macro attributes on the floor here
drop(attrs);
})
}
- ast::ExprInPlace(placer, value_expr) => {
+ ast::ExprKind::InPlace(placer, value_expr) => {
// Ensure feature-gate is enabled
feature_gate::check_for_placement_in(
fld.cx.ecfg.features,
let placer = fld.fold_expr(placer);
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))
}
- ast::ExprWhile(cond, body, opt_ident) => {
+ ast::ExprKind::While(cond, body, opt_ident) => {
let cond = fld.fold_expr(cond);
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))
}
- ast::ExprWhileLet(pat, expr, body, opt_ident) => {
+ ast::ExprKind::WhileLet(pat, expr, body, opt_ident) => {
let pat = fld.fold_pat(pat);
let expr = fld.fold_expr(expr);
});
assert!(rewritten_pats.len() == 1);
- fld.cx.expr(span, ast::ExprWhileLet(rewritten_pats.remove(0), expr, body, opt_ident))
- .with_attrs(fold_thin_attrs(attrs, fld))
+ let wl = ast::ExprKind::WhileLet(rewritten_pats.remove(0), expr, body, opt_ident);
+ 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);
- 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))
}
- ast::ExprForLoop(pat, head, body, opt_ident) => {
+ ast::ExprKind::ForLoop(pat, head, body, opt_ident) => {
let pat = fld.fold_pat(pat);
// Hygienic renaming of the for loop body (for loop binds its pattern).
assert!(rewritten_pats.len() == 1);
let head = fld.fold_expr(head);
- fld.cx.expr(span, ast::ExprForLoop(rewritten_pats.remove(0), head, body, opt_ident))
- .with_attrs(fold_thin_attrs(attrs, fld))
+ let fl = ast::ExprKind::ForLoop(rewritten_pats.remove(0), head, body, opt_ident);
+ 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);
// Hygienic renaming of the body.
let else_opt = else_opt.map(|else_opt| fld.fold_expr(else_opt));
let sub_expr = fld.fold_expr(sub_expr);
- fld.cx.expr(span, ast::ExprIfLet(rewritten_pats.remove(0), sub_expr, body, else_opt))
- .with_attrs(fold_thin_attrs(attrs, fld))
+ let il = ast::ExprKind::IfLet(rewritten_pats.remove(0), sub_expr, body, else_opt);
+ 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)
= 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_block);
P(ast::Expr{id:id, node: new_node, span: fld.new_span(span),
impl<'v> Visitor<'v> for PathExprFinderContext {
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());
}
visit::walk_expr(self, expr);
0)
}
- // closure arg hygiene (ExprClosure)
+ // closure arg hygiene (ExprKind::Closure)
// expands to fn f(){(|x_1 : i32| {(x_2 + x_1)})(3);}
#[test]
fn closure_arg_hygiene(){
// FIXME: This is wrong
P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprLit(P(self.clone())),
+ node: ast::ExprKind::Lit(P(self.clone())),
span: DUMMY_SP,
attrs: None,
}).to_tokens(cx)
// But we keep these checks as a pre-expansion check to catch
// 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);
}
- 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);
}
fn visit_expr(&mut self, e: &ast::Expr) {
match e.node {
- ast::ExprBox(_) => {
+ ast::ExprKind::Box(_) => {
self.gate_feature("box_syntax",
e.span,
"box expression syntax is experimental; \
you can call `Box::new` instead.");
}
- ast::ExprType(..) => {
+ ast::ExprKind::Type(..) => {
self.gate_feature("type_ascription", e.span,
"type ascription is experimental");
}
Expr {
id: folder.new_id(id),
node: match node {
- ExprBox(e) => {
- ExprBox(folder.fold_expr(e))
+ ExprKind::Box(e) => {
+ ExprKind::Box(folder.fold_expr(e))
}
- ExprInPlace(p, e) => {
- ExprInPlace(folder.fold_expr(p), folder.fold_expr(e))
+ ExprKind::InPlace(p, e) => {
+ ExprKind::InPlace(folder.fold_expr(p), folder.fold_expr(e))
}
- ExprVec(exprs) => {
- ExprVec(folder.fold_exprs(exprs))
+ ExprKind::Vec(exprs) => {
+ ExprKind::Vec(folder.fold_exprs(exprs))
}
- ExprRepeat(expr, count) => {
- ExprRepeat(folder.fold_expr(expr), folder.fold_expr(count))
+ ExprKind::Repeat(expr, count) => {
+ ExprKind::Repeat(folder.fold_expr(expr), folder.fold_expr(count))
}
- ExprTup(exprs) => ExprTup(folder.fold_exprs(exprs)),
- ExprCall(f, args) => {
- ExprCall(folder.fold_expr(f),
+ ExprKind::Tup(exprs) => ExprKind::Tup(folder.fold_exprs(exprs)),
+ ExprKind::Call(f, args) => {
+ ExprKind::Call(folder.fold_expr(f),
folder.fold_exprs(args))
}
- ExprMethodCall(i, tps, args) => {
- ExprMethodCall(
+ ExprKind::MethodCall(i, tps, args) => {
+ ExprKind::MethodCall(
respan(folder.new_span(i.span), folder.fold_ident(i.node)),
tps.move_map(|x| folder.fold_ty(x)),
folder.fold_exprs(args))
}
- ExprBinary(binop, lhs, rhs) => {
- ExprBinary(binop,
+ ExprKind::Binary(binop, lhs, rhs) => {
+ ExprKind::Binary(binop,
folder.fold_expr(lhs),
folder.fold_expr(rhs))
}
- ExprUnary(binop, ohs) => {
- ExprUnary(binop, folder.fold_expr(ohs))
+ ExprKind::Unary(binop, ohs) => {
+ ExprKind::Unary(binop, folder.fold_expr(ohs))
}
- ExprLit(l) => ExprLit(l),
- ExprCast(expr, ty) => {
- ExprCast(folder.fold_expr(expr), folder.fold_ty(ty))
+ ExprKind::Lit(l) => ExprKind::Lit(l),
+ ExprKind::Cast(expr, ty) => {
+ ExprKind::Cast(folder.fold_expr(expr), folder.fold_ty(ty))
}
- ExprType(expr, ty) => {
- ExprType(folder.fold_expr(expr), folder.fold_ty(ty))
+ ExprKind::Type(expr, ty) => {
+ ExprKind::Type(folder.fold_expr(expr), folder.fold_ty(ty))
}
- ExprAddrOf(m, ohs) => ExprAddrOf(m, folder.fold_expr(ohs)),
- ExprIf(cond, tr, fl) => {
- ExprIf(folder.fold_expr(cond),
+ ExprKind::AddrOf(m, ohs) => ExprKind::AddrOf(m, folder.fold_expr(ohs)),
+ ExprKind::If(cond, tr, fl) => {
+ ExprKind::If(folder.fold_expr(cond),
folder.fold_block(tr),
fl.map(|x| folder.fold_expr(x)))
}
- ExprIfLet(pat, expr, tr, fl) => {
- ExprIfLet(folder.fold_pat(pat),
+ ExprKind::IfLet(pat, expr, tr, fl) => {
+ ExprKind::IfLet(folder.fold_pat(pat),
folder.fold_expr(expr),
folder.fold_block(tr),
fl.map(|x| folder.fold_expr(x)))
}
- ExprWhile(cond, body, opt_ident) => {
- ExprWhile(folder.fold_expr(cond),
+ ExprKind::While(cond, body, opt_ident) => {
+ ExprKind::While(folder.fold_expr(cond),
folder.fold_block(body),
opt_ident.map(|i| folder.fold_ident(i)))
}
- ExprWhileLet(pat, expr, body, opt_ident) => {
- ExprWhileLet(folder.fold_pat(pat),
+ ExprKind::WhileLet(pat, expr, body, opt_ident) => {
+ ExprKind::WhileLet(folder.fold_pat(pat),
folder.fold_expr(expr),
folder.fold_block(body),
opt_ident.map(|i| folder.fold_ident(i)))
}
- ExprForLoop(pat, iter, body, opt_ident) => {
- ExprForLoop(folder.fold_pat(pat),
+ ExprKind::ForLoop(pat, iter, body, opt_ident) => {
+ ExprKind::ForLoop(folder.fold_pat(pat),
folder.fold_expr(iter),
folder.fold_block(body),
opt_ident.map(|i| folder.fold_ident(i)))
}
- ExprLoop(body, opt_ident) => {
- ExprLoop(folder.fold_block(body),
+ ExprKind::Loop(body, opt_ident) => {
+ ExprKind::Loop(folder.fold_block(body),
opt_ident.map(|i| folder.fold_ident(i)))
}
- ExprMatch(expr, arms) => {
- ExprMatch(folder.fold_expr(expr),
+ ExprKind::Match(expr, arms) => {
+ ExprKind::Match(folder.fold_expr(expr),
arms.move_map(|x| folder.fold_arm(x)))
}
- ExprClosure(capture_clause, decl, body) => {
- ExprClosure(capture_clause,
+ ExprKind::Closure(capture_clause, decl, body) => {
+ ExprKind::Closure(capture_clause,
folder.fold_fn_decl(decl),
folder.fold_block(body))
}
- ExprBlock(blk) => ExprBlock(folder.fold_block(blk)),
- ExprAssign(el, er) => {
- ExprAssign(folder.fold_expr(el), folder.fold_expr(er))
+ ExprKind::Block(blk) => ExprKind::Block(folder.fold_block(blk)),
+ ExprKind::Assign(el, er) => {
+ ExprKind::Assign(folder.fold_expr(el), folder.fold_expr(er))
}
- ExprAssignOp(op, el, er) => {
- ExprAssignOp(op,
+ ExprKind::AssignOp(op, el, er) => {
+ ExprKind::AssignOp(op,
folder.fold_expr(el),
folder.fold_expr(er))
}
- ExprField(el, ident) => {
- ExprField(folder.fold_expr(el),
+ ExprKind::Field(el, ident) => {
+ ExprKind::Field(folder.fold_expr(el),
respan(folder.new_span(ident.span),
folder.fold_ident(ident.node)))
}
- ExprTupField(el, ident) => {
- ExprTupField(folder.fold_expr(el),
+ ExprKind::TupField(el, ident) => {
+ ExprKind::TupField(folder.fold_expr(el),
respan(folder.new_span(ident.span),
folder.fold_usize(ident.node)))
}
- ExprIndex(el, er) => {
- ExprIndex(folder.fold_expr(el), folder.fold_expr(er))
+ ExprKind::Index(el, er) => {
+ ExprKind::Index(folder.fold_expr(el), folder.fold_expr(er))
}
- ExprRange(e1, e2) => {
- ExprRange(e1.map(|x| folder.fold_expr(x)),
+ ExprKind::Range(e1, e2) => {
+ ExprKind::Range(e1.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 }| {
QSelf {
ty: folder.fold_ty(ty),
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),
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),
folder.fold_ident(label.node)))
),
- ExprRet(e) => ExprRet(e.map(|x| folder.fold_expr(x))),
- ExprInlineAsm(InlineAsm {
+ ExprKind::Ret(e) => ExprKind::Ret(e.map(|x| folder.fold_expr(x))),
+ ExprKind::InlineAsm(InlineAsm {
inputs,
outputs,
asm,
alignstack,
dialect,
expn_id,
- }) => ExprInlineAsm(InlineAsm {
+ }) => ExprKind::InlineAsm(InlineAsm {
inputs: inputs.move_map(|(c, input)| {
(c, folder.fold_expr(input))
}),
dialect: dialect,
expn_id: expn_id,
}),
- ExprMac(mac) => ExprMac(folder.fold_mac(mac)),
- ExprStruct(path, fields, maybe_expr) => {
- ExprStruct(folder.fold_path(path),
+ ExprKind::Mac(mac) => ExprKind::Mac(folder.fold_mac(mac)),
+ ExprKind::Struct(path, fields, maybe_expr) => {
+ ExprKind::Struct(folder.fold_path(path),
fields.move_map(|x| folder.fold_field(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),
attrs: attrs.map_thin_attrs(|v| fold_attrs(v, folder)),
/// isn't parsed as (if true {...} else {...} | x) | 5
pub fn expr_requires_semi_to_be_stmt(e: &ast::Expr) -> bool {
match e.node {
- ast::ExprIf(..) |
- ast::ExprIfLet(..) |
- ast::ExprMatch(..) |
- ast::ExprBlock(_) |
- ast::ExprWhile(..) |
- ast::ExprWhileLet(..) |
- ast::ExprLoop(..) |
- ast::ExprForLoop(..) => false,
+ ast::ExprKind::If(..) |
+ ast::ExprKind::IfLet(..) |
+ ast::ExprKind::Match(..) |
+ ast::ExprKind::Block(_) |
+ ast::ExprKind::While(..) |
+ ast::ExprKind::WhileLet(..) |
+ ast::ExprKind::Loop(..) |
+ ast::ExprKind::ForLoop(..) => false,
_ => true,
}
}
pub fn expr_is_simple_block(e: &ast::Expr) -> bool {
match e.node {
- ast::ExprBlock(ref block) => block.rules == BlockCheckMode::Default,
+ ast::ExprKind::Block(ref block) => block.rules == BlockCheckMode::Default,
_ => false,
}
}
assert!(string_to_expr("a".to_string()) ==
P(ast::Expr{
id: ast::DUMMY_NODE_ID,
- node: ast::ExprPath(None, ast::Path {
+ node: ast::ExprKind::Path(None, ast::Path {
span: sp(0, 1),
global: false,
segments: vec!(
assert!(string_to_expr("::a::b".to_string()) ==
P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprPath(None, ast::Path {
+ node: ast::ExprKind::Path(None, ast::Path {
span: sp(0, 6),
global: true,
segments: vec!(
assert!(string_to_expr("return d".to_string()) ==
P(ast::Expr{
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,
- node:ast::ExprPath(None, ast::Path{
+ node:ast::ExprKind::Path(None, ast::Path{
span: sp(7, 8),
global: false,
segments: vec!(
Some(P(Spanned{
node: ast::StmtExpr(P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprPath(None, ast::Path {
+ node: ast::ExprKind::Path(None, ast::Path {
span:sp(0,1),
global:false,
segments: vec!(
stmts: vec!(P(Spanned{
node: ast::StmtSemi(P(ast::Expr{
id: ast::DUMMY_NODE_ID,
- node: ast::ExprPath(None,
+ node: ast::ExprKind::Path(None,
ast::Path{
span:sp(17,18),
global:false,
"foo!( fn main() { body } )".to_string(), vec![], &sess);
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"),
};
use ast::{Constness, ConstTraitItem, Crate, CrateConfig};
use ast::{Decl, DeclKind};
use ast::{EMPTY_CTXT, EnumDef, ExplicitSelf};
-use ast::{Expr, Expr_, ExprAddrOf, ExprMatch, ExprAgain};
-use ast::{ExprAssign, ExprAssignOp, ExprBinary, ExprBlock, ExprBox};
-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::{Expr, ExprKind};
+use ast::{Field, FnDecl};
use ast::{ForeignItem, ForeignItemStatic, ForeignItemFn, FunctionRetTy};
use ast::{Ident, Inherited, ImplItem, Item, Item_, ItemStatic};
use ast::{ItemEnum, ItemFn, ItemForeignMod, ItemImpl, ItemConst};
_ => unreachable!()
};
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(_)) => {
// FIXME: The following avoids an issue with lexical borrowck scopes,
_ => unreachable!()
};
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
};
pub fn commit_expr(&mut self, e: &Expr, edible: &[token::Token],
inedible: &[token::Token]) -> PResult<'a, ()> {
debug!("commit_expr {:?}", e);
- if let ExprPath(..) = e.node {
+ if let ExprKind::Path(..) = e.node {
// might be unit-struct construction; check for recoverableinput error.
let expected = edible.iter()
.cloned()
match *tok {
token::Interpolated(token::NtExpr(ref v)) => {
match v.node {
- ExprLit(ref lit) => { Ok(lit.node.clone()) }
+ ExprKind::Lit(ref lit) => { Ok(lit.node.clone()) }
_ => { return self.unexpected_last(tok); }
}
}
let lo = self.span.lo;
let literal = P(try!(self.parse_lit()));
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 {
let minus_hi = self.last_span.hi;
}
pub fn mk_expr(&mut self, lo: BytePos, hi: BytePos,
- node: Expr_, attrs: ThinAttributes) -> P<Expr> {
+ node: ExprKind, attrs: ThinAttributes) -> P<Expr> {
P(Expr {
id: ast::DUMMY_NODE_ID,
node: node,
})
}
- pub fn mk_unary(&mut self, unop: ast::UnOp, expr: P<Expr>) -> ast::Expr_ {
- ExprUnary(unop, expr)
+ pub fn mk_unary(&mut self, unop: ast::UnOp, expr: P<Expr>) -> ast::ExprKind {
+ ExprKind::Unary(unop, expr)
}
- pub fn mk_binary(&mut self, binop: ast::BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ast::Expr_ {
- ExprBinary(binop, lhs, rhs)
+ pub fn mk_binary(&mut self, binop: ast::BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ast::ExprKind {
+ ExprKind::Binary(binop, lhs, rhs)
}
- pub fn mk_call(&mut self, f: P<Expr>, args: Vec<P<Expr>>) -> ast::Expr_ {
- ExprCall(f, args)
+ pub fn mk_call(&mut self, f: P<Expr>, args: Vec<P<Expr>>) -> ast::ExprKind {
+ ExprKind::Call(f, args)
}
fn mk_method_call(&mut self,
ident: ast::SpannedIdent,
tps: Vec<P<Ty>>,
args: Vec<P<Expr>>)
- -> ast::Expr_ {
- ExprMethodCall(ident, tps, args)
+ -> ast::ExprKind {
+ ExprKind::MethodCall(ident, tps, args)
}
- pub fn mk_index(&mut self, expr: P<Expr>, idx: P<Expr>) -> ast::Expr_ {
- ExprIndex(expr, idx)
+ pub fn mk_index(&mut self, expr: P<Expr>, idx: P<Expr>) -> ast::ExprKind {
+ ExprKind::Index(expr, idx)
}
pub fn mk_range(&mut self,
start: Option<P<Expr>>,
end: Option<P<Expr>>)
- -> ast::Expr_ {
- ExprRange(start, end)
+ -> ast::ExprKind {
+ ExprKind::Range(start, end)
}
- pub fn mk_field(&mut self, expr: P<Expr>, ident: ast::SpannedIdent) -> ast::Expr_ {
- ExprField(expr, ident)
+ pub fn mk_field(&mut self, expr: P<Expr>, ident: ast::SpannedIdent) -> ast::ExprKind {
+ ExprKind::Field(expr, ident)
}
- pub fn mk_tup_field(&mut self, expr: P<Expr>, idx: codemap::Spanned<usize>) -> ast::Expr_ {
- ExprTupField(expr, idx)
+ pub fn mk_tup_field(&mut self, expr: P<Expr>, idx: codemap::Spanned<usize>) -> ast::ExprKind {
+ ExprKind::TupField(expr, idx)
}
pub fn mk_assign_op(&mut self, binop: ast::BinOp,
- lhs: P<Expr>, rhs: P<Expr>) -> ast::Expr_ {
- ExprAssignOp(binop, lhs, rhs)
+ lhs: P<Expr>, rhs: P<Expr>) -> ast::ExprKind {
+ ExprKind::AssignOp(binop, lhs, rhs)
}
pub fn mk_mac_expr(&mut self, lo: BytePos, hi: BytePos,
m: Mac_, attrs: ThinAttributes) -> P<Expr> {
P(Expr {
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),
attrs: attrs,
})
P(Expr {
id: ast::DUMMY_NODE_ID,
- node: ExprLit(lv_lit),
+ node: ExprKind::Lit(lv_lit),
span: *span,
attrs: attrs,
})
let lo = self.span.lo;
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().
match self.token {
hi = self.last_span.hi;
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 {
- Ok(self.mk_expr(lo, hi, ExprTup(es), attrs))
+ Ok(self.mk_expr(lo, hi, ExprKind::Tup(es), attrs))
}
},
token::OpenDelim(token::Brace) => {
}, token::Plain) => {
self.bump();
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;
}
token::OpenDelim(token::Bracket) => {
if self.check(&token::CloseDelim(token::Bracket)) {
// Empty vector.
self.bump();
- ex = ExprVec(Vec::new());
+ ex = ExprKind::Vec(Vec::new());
} else {
// Nonempty vector.
let first_expr = try!(self.parse_expr());
self.bump();
let count = try!(self.parse_expr());
try!(self.expect(&token::CloseDelim(token::Bracket)));
- ex = ExprRepeat(first_expr, count);
+ ex = ExprKind::Repeat(first_expr, count);
} else if self.check(&token::Comma) {
// Vector with two or more elements.
self.bump();
));
let mut exprs = vec!(first_expr);
exprs.extend(remaining_exprs);
- ex = ExprVec(exprs);
+ ex = ExprKind::Vec(exprs);
} else {
// Vector with one element.
try!(self.expect(&token::CloseDelim(token::Bracket)));
- ex = ExprVec(vec!(first_expr));
+ ex = ExprKind::Vec(vec!(first_expr));
}
}
hi = self.last_span.hi;
let (qself, path) =
try!(self.parse_qualified_path(LifetimeAndTypesWithColons));
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) {
let lo = self.last_span.lo;
}
if self.eat_keyword(keywords::Continue) {
let ex = if self.token.is_lifetime() {
- let ex = ExprAgain(Some(Spanned{
+ let ex = ExprKind::Again(Some(Spanned{
node: self.get_lifetime(),
span: self.span
}));
self.bump();
ex
} else {
- ExprAgain(None)
+ ExprKind::Again(None)
};
let hi = self.last_span.hi;
return Ok(self.mk_expr(lo, hi, ex, attrs));
if self.token.can_begin_expr() {
let e = try!(self.parse_expr());
hi = e.span.hi;
- ex = ExprRet(Some(e));
+ ex = ExprKind::Ret(Some(e));
} else {
- ex = ExprRet(None);
+ ex = ExprKind::Ret(None);
}
} else if self.eat_keyword(keywords::Break) {
if self.token.is_lifetime() {
- ex = ExprBreak(Some(Spanned {
+ ex = ExprKind::Break(Some(Spanned {
node: self.get_lifetime(),
span: self.span
}));
self.bump();
} else {
- ex = ExprBreak(None);
+ ex = ExprKind::Break(None);
}
hi = self.last_span.hi;
} else if self.token.is_keyword(keywords::Let) {
hi = self.span.hi;
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));
}
}
hi = pth.span.hi;
- ex = ExprPath(None, pth);
+ ex = ExprKind::Path(None, pth);
} else {
// other literal expression
let lit = try!(self.parse_lit());
hi = lit.span.hi;
- ex = ExprLit(P(lit));
+ ex = ExprKind::Lit(P(lit));
}
}
}
let attrs = outer_attrs.append(inner_attrs);
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
expr.map(|mut expr| {
expr.attrs.update(|a| a.prepend(attrs));
match expr.node {
- ExprIf(..) | ExprIfLet(..) => {
+ ExprKind::If(..) | ExprKind::IfLet(..) => {
if !expr.attrs.as_attr_slice().is_empty() {
// Just point to the first attribute in there...
let span = expr.attrs.as_attr_slice()[0].span;
let e = self.parse_prefix_expr(None);
let (span, e) = try!(self.interpolated_or_expr_span(e));
hi = span.hi;
- ExprAddrOf(m, e)
+ ExprKind::AddrOf(m, e)
}
token::Ident(..) if self.token.is_keyword(keywords::In) => {
self.bump();
let blk = try!(self.parse_block());
let span = blk.span;
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);
- ExprInPlace(place, blk_expr)
+ ExprKind::InPlace(place, blk_expr)
}
token::Ident(..) if self.token.is_keyword(keywords::Box) => {
self.bump();
let e = self.parse_prefix_expr(None);
let (span, e) = try!(self.interpolated_or_expr_span(e));
hi = span.hi;
- ExprBox(e)
+ ExprKind::Box(e)
}
_ => return self.parse_dot_or_call_expr(Some(attrs))
};
if op == AssocOp::As {
let rhs = try!(self.parse_ty());
lhs = self.mk_expr(lhs_span.lo, rhs.span.hi,
- ExprCast(lhs, rhs), None);
+ ExprKind::Cast(lhs, rhs), None);
continue
} else if op == AssocOp::Colon {
let rhs = try!(self.parse_ty());
lhs = self.mk_expr(lhs_span.lo, rhs.span.hi,
- ExprType(lhs, rhs), None);
+ ExprKind::Type(lhs, rhs), None);
continue
} else if op == AssocOp::DotDot {
// If we didn’t have to handle `x..`, it would be pretty easy to generalise
self.mk_expr(lhs_span.lo, rhs_span.hi, binary, None)
}
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 =>
- 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) => {
let aop = match k {
token::Plus => BinOpKind::Add,
fn check_no_chained_comparison(&mut self, lhs: &Expr, outer_op: &AssocOp) {
debug_assert!(outer_op.is_comparison());
match lhs.node {
- ExprBinary(op, _, _) if op.node.is_comparison() => {
+ ExprKind::Binary(op, _, _) if op.node.is_comparison() => {
// respan to include both operators
let op_span = mk_sp(op.span.lo, self.span.hi);
let mut err = self.diagnostic().struct_span_err(op_span,
hi = elexpr.span.hi;
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)
} else {
(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`
Ok(self.mk_expr(
lo,
body.span.hi,
- ExprClosure(capture_clause, decl, body), attrs))
+ ExprKind::Closure(capture_clause, decl, body), attrs))
}
// `else` token already eaten
return self.parse_if_expr(None);
} else {
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));
}
}
let hi = self.last_span.hi;
Ok(self.mk_expr(span_lo, hi,
- ExprForLoop(pat, expr, loop_block, opt_ident),
+ ExprKind::ForLoop(pat, expr, loop_block, opt_ident),
attrs))
}
let (iattrs, body) = try!(self.parse_inner_attrs_and_block());
let attrs = attrs.append(iattrs.into_thin_attrs());
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));
}
let (iattrs, body) = try!(self.parse_inner_attrs_and_block());
let attrs = attrs.append(iattrs.into_thin_attrs());
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
let (iattrs, body) = try!(self.parse_inner_attrs_and_block());
let attrs = attrs.append(iattrs.into_thin_attrs());
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
}
let hi = self.span.hi;
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> {
(None, try!(self.parse_path(LifetimeAndTypesWithColons)))
};
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 {
self.parse_pat_literal_maybe_minus()
}
token::DotDotDot => {
// Parse range
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();
let end = try!(self.parse_pat_range_end());
pat = PatRange(begin, end);
fn needs_parentheses(expr: &ast::Expr) -> bool {
match expr.node {
- ast::ExprAssign(..) | ast::ExprBinary(..) |
- ast::ExprClosure(..) |
- ast::ExprAssignOp(..) | ast::ExprCast(..) |
- ast::ExprInPlace(..) | ast::ExprType(..) => true,
+ ast::ExprKind::Assign(..) | ast::ExprKind::Binary(..) |
+ ast::ExprKind::Closure(..) |
+ ast::ExprKind::AssignOp(..) | ast::ExprKind::Cast(..) |
+ ast::ExprKind::InPlace(..) | ast::ExprKind::Type(..) => true,
_ => false,
}
}
Some(_else) => {
match _else.node {
// "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.ibox(0));
try!(word(&mut self.s, " else if "));
self.print_else(e.as_ref().map(|e| &**e))
}
// "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.ibox(0));
try!(word(&mut self.s, " else if let "));
self.print_else(e.as_ref().map(|e| &**e))
}
// "final else"
- ast::ExprBlock(ref b) => {
+ ast::ExprKind::Block(ref b) => {
try!(self.cbox(INDENT_UNIT - 1));
try!(self.ibox(0));
try!(word(&mut self.s, " else "));
pub fn check_expr_bin_needs_paren(&mut self, sub_expr: &ast::Expr,
binop: ast::BinOp) -> bool {
match sub_expr.node {
- ast::ExprBinary(ref sub_op, _, _) => {
+ ast::ExprKind::Binary(ref sub_op, _, _) => {
if AssocOp::from_ast_binop(sub_op.node).precedence() <
AssocOp::from_ast_binop(binop.node).precedence() {
true
try!(self.ibox(INDENT_UNIT));
try!(self.ann.pre(self, NodeExpr(expr)));
match expr.node {
- ast::ExprBox(ref expr) => {
+ ast::ExprKind::Box(ref expr) => {
try!(self.word_space("box"));
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));
}
- ast::ExprVec(ref exprs) => {
+ ast::ExprKind::Vec(ref exprs) => {
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));
}
- 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));
}
- ast::ExprTup(ref exprs) => {
+ ast::ExprKind::Tup(ref exprs) => {
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[..]));
}
- ast::ExprMethodCall(ident, ref tys, ref args) => {
+ ast::ExprKind::MethodCall(ident, ref tys, ref 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));
}
- ast::ExprUnary(op, ref expr) => {
+ ast::ExprKind::Unary(op, ref 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));
}
- ast::ExprLit(ref lit) => {
+ ast::ExprKind::Lit(ref lit) => {
try!(self.print_literal(&**lit));
}
- ast::ExprCast(ref expr, ref ty) => {
- if let ast::ExprCast(..) = expr.node {
+ ast::ExprKind::Cast(ref expr, ref ty) => {
+ if let ast::ExprKind::Cast(..) = expr.node {
try!(self.print_expr(&**expr));
} else {
try!(self.print_expr_maybe_paren(&**expr));
try!(self.word_space("as"));
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.word_space(":"));
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)));
}
- 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)));
}
- ast::ExprWhile(ref test, ref blk, opt_ident) => {
+ ast::ExprKind::While(ref test, ref blk, opt_ident) => {
if let Some(ident) = opt_ident {
try!(self.print_ident(ident));
try!(self.word_space(":"));
try!(space(&mut self.s));
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 {
try!(self.print_ident(ident));
try!(self.word_space(":"));
try!(space(&mut self.s));
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 {
try!(self.print_ident(ident));
try!(self.word_space(":"));
try!(space(&mut self.s));
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 {
try!(self.print_ident(ident));
try!(self.word_space(":"));
try!(space(&mut self.s));
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.ibox(4));
try!(self.word_nbsp("match"));
}
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_fn_block_args(&**decl));
// we extract the block, so as not to create another set of boxes
let i_expr = body.expr.as_ref().unwrap();
match i_expr.node {
- ast::ExprBlock(ref blk) => {
+ ast::ExprKind::Block(ref blk) => {
try!(self.print_block_unclosed_with_attrs(
&**blk,
i_expr.attrs.as_attr_slice()));
// empty box to satisfy the close.
try!(self.ibox(0));
}
- ast::ExprBlock(ref blk) => {
+ ast::ExprKind::Block(ref blk) => {
// containing cbox, will be closed by print-block at }
try!(self.cbox(INDENT_UNIT));
// head-box, will be closed by print-block after {
try!(self.ibox(0));
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!(space(&mut self.s));
try!(self.word_space("="));
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!(space(&mut self.s));
try!(word(&mut self.s, op.node.to_string()));
try!(self.word_space("="));
try!(self.print_expr(&**rhs));
}
- ast::ExprField(ref expr, id) => {
+ ast::ExprKind::Field(ref expr, id) => {
try!(self.print_expr(&**expr));
try!(word(&mut self.s, "."));
try!(self.print_ident(id.node));
}
- ast::ExprTupField(ref expr, id) => {
+ ast::ExprKind::TupField(ref expr, id) => {
try!(self.print_expr(&**expr));
try!(word(&mut self.s, "."));
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!(word(&mut self.s, "["));
try!(self.print_expr(&**index));
try!(word(&mut self.s, "]"));
}
- ast::ExprRange(ref start, ref end) => {
+ ast::ExprKind::Range(ref start, ref end) => {
if let &Some(ref e) = start {
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))
}
- ast::ExprPath(Some(ref qself), ref path) => {
+ ast::ExprKind::Path(Some(ref qself), ref path) => {
try!(self.print_qpath(path, qself, true))
}
- ast::ExprBreak(opt_ident) => {
+ ast::ExprKind::Break(opt_ident) => {
try!(word(&mut self.s, "break"));
try!(space(&mut self.s));
if let Some(ident) = opt_ident {
try!(space(&mut self.s));
}
}
- ast::ExprAgain(opt_ident) => {
+ ast::ExprKind::Again(opt_ident) => {
try!(word(&mut self.s, "continue"));
try!(space(&mut self.s));
if let Some(ident) = opt_ident {
try!(space(&mut self.s))
}
}
- ast::ExprRet(ref result) => {
+ ast::ExprKind::Ret(ref result) => {
try!(word(&mut self.s, "return"));
match *result {
Some(ref expr) => {
_ => ()
}
}
- ast::ExprInlineAsm(ref a) => {
+ ast::ExprKind::InlineAsm(ref a) => {
try!(word(&mut self.s, "asm!"));
try!(self.popen());
try!(self.print_string(&a.asm, a.asm_str_style));
try!(self.pclose());
}
- ast::ExprMac(ref m) => try!(self.print_mac(m, token::Paren)),
- ast::ExprParen(ref e) => {
+ ast::ExprKind::Mac(ref m) => try!(self.print_mac(m, token::Paren)),
+ ast::ExprKind::Paren(ref e) => {
try!(self.popen());
try!(self.print_inner_attributes_inline(attrs));
try!(self.print_expr(&**e));
try!(self.word_space("=>"));
match arm.body.node {
- ast::ExprBlock(ref blk) => {
+ ast::ExprKind::Block(ref blk) => {
// the block will close the pattern's ibox
try!(self.print_block_unclosed_indent(&**blk, INDENT_UNIT));
//!
//! * **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
-//! `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
//! 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`,
P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprAddrOf(ast::MutImmutable,
+ node: ast::ExprKind::AddrOf(ast::MutImmutable,
P(ast::Expr {
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)
}).collect()),
span: DUMMY_SP,
pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
match expression.node {
- ExprBox(ref subexpression) => {
+ ExprKind::Box(ref subexpression) => {
visitor.visit_expr(subexpression)
}
- ExprInPlace(ref place, ref subexpression) => {
+ ExprKind::InPlace(ref place, ref subexpression) => {
visitor.visit_expr(place);
visitor.visit_expr(subexpression)
}
- ExprVec(ref subexpressions) => {
+ ExprKind::Vec(ref 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(count)
}
- ExprStruct(ref path, ref fields, ref optional_base) => {
+ ExprKind::Struct(ref path, ref fields, ref optional_base) => {
visitor.visit_path(path, expression.id);
for field in fields {
visitor.visit_ident(field.ident.span, field.ident.node);
}
walk_list!(visitor, visit_expr, optional_base);
}
- ExprTup(ref subexpressions) => {
+ ExprKind::Tup(ref 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);
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);
walk_list!(visitor, visit_expr, arguments);
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(right_expression)
}
- ExprAddrOf(_, ref subexpression) | ExprUnary(_, ref subexpression) => {
+ ExprKind::AddrOf(_, ref subexpression) | ExprKind::Unary(_, ref subexpression) => {
visitor.visit_expr(subexpression)
}
- ExprLit(_) => {}
- ExprCast(ref subexpression, ref typ) | ExprType(ref subexpression, ref typ) => {
+ ExprKind::Lit(_) => {}
+ ExprKind::Cast(ref subexpression, ref typ) | ExprKind::Type(ref subexpression, ref typ) => {
visitor.visit_expr(subexpression);
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_block(if_block);
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_block(block);
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_expr(subexpression);
visitor.visit_block(if_block);
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_expr(subexpression);
visitor.visit_block(block);
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_expr(subexpression);
visitor.visit_block(block);
walk_opt_ident(visitor, expression.span, opt_ident)
}
- ExprLoop(ref block, opt_ident) => {
+ ExprKind::Loop(ref block, opt_ident) => {
visitor.visit_block(block);
walk_opt_ident(visitor, expression.span, opt_ident)
}
- ExprMatch(ref subexpression, ref arms) => {
+ ExprKind::Match(ref subexpression, ref arms) => {
visitor.visit_expr(subexpression);
walk_list!(visitor, visit_arm, arms);
}
- ExprClosure(_, ref function_declaration, ref body) => {
+ ExprKind::Closure(_, ref function_declaration, ref body) => {
visitor.visit_fn(FnKind::Closure,
function_declaration,
body,
expression.span,
expression.id)
}
- ExprBlock(ref block) => visitor.visit_block(block),
- ExprAssign(ref left_hand_expression, ref right_hand_expression) => {
+ ExprKind::Block(ref block) => visitor.visit_block(block),
+ ExprKind::Assign(ref left_hand_expression, ref right_hand_expression) => {
visitor.visit_expr(right_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(left_expression)
}
- ExprField(ref subexpression, ref ident) => {
+ ExprKind::Field(ref subexpression, ref ident) => {
visitor.visit_expr(subexpression);
visitor.visit_ident(ident.span, ident.node);
}
- ExprTupField(ref subexpression, _) => {
+ ExprKind::TupField(ref 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(index_expression)
}
- ExprRange(ref start, ref end) => {
+ ExprKind::Range(ref start, ref end) => {
walk_list!(visitor, visit_expr, start);
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 {
visitor.visit_ty(&qself.ty);
}
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 {
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);
}
- ExprMac(ref mac) => visitor.visit_mac(mac),
- ExprParen(ref subexpression) => {
+ ExprKind::Mac(ref mac) => visitor.visit_mac(mac),
+ ExprKind::Paren(ref subexpression) => {
visitor.visit_expr(subexpression)
}
- ExprInlineAsm(ref ia) => {
+ ExprKind::InlineAsm(ref ia) => {
for &(_, ref input) in &ia.inputs {
visitor.visit_expr(&input)
}
MacEager::expr(P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprInlineAsm(ast::InlineAsm {
+ node: ast::ExprKind::InlineAsm(ast::InlineAsm {
asm: token::intern_and_get_ident(&asm),
asm_str_style: asm_str_style.unwrap(),
outputs: outputs,
let mut accumulator = String::new();
for e in es {
match e.node {
- ast::ExprLit(ref lit) => {
+ ast::ExprKind::Lit(ref lit) => {
match lit.node {
ast::LitStr(ref s, _) |
ast::LitFloat(ref s, _) |
let e = P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprPath(None,
+ node: ast::ExprKind::Path(None,
ast::Path {
span: sp,
global: false,
use deriving::generic::*;
use deriving::generic::ty::*;
-use syntax::ast::{MetaItem, Expr, ExprRet, MutMutable};
+use syntax::ast::{MetaItem, Expr, ExprKind, MutMutable};
use syntax::codemap::Span;
use syntax::ext::base::{ExtCtxt,Annotatable};
use syntax::ext::build::AstBuilder;
let call = if i != last {
cx.expr_try(span, call)
} else {
- cx.expr(span, ExprRet(Some(call)))
+ cx.expr(span, ExprKind::Ret(Some(call)))
};
stmts.push(cx.stmt_expr(call));
}
// unit structs have no fields and need to return Ok()
if stmts.is_empty() {
- let ret_ok = cx.expr(trait_span,
- ExprRet(Some(cx.expr_ok(trait_span,
- cx.expr_tuple(trait_span, vec![])))));
+ let ok = cx.expr_ok(trait_span, cx.expr_tuple(trait_span, vec![]));
+ let ret_ok = cx.expr(trait_span, ExprKind::Ret(Some(ok)));
stmts.push(cx.stmt_expr(ret_ok));
}
let call = if i != last {
cx.expr_try(span, call)
} else {
- cx.expr(span, ExprRet(Some(call)))
+ cx.expr(span, ExprKind::Ret(Some(call)))
};
stmts.push(cx.stmt_expr(call));
}
} else {
- let ret_ok = cx.expr(trait_span,
- ExprRet(Some(cx.expr_ok(trait_span,
- cx.expr_tuple(trait_span, vec![])))));
+ let ok = cx.expr_ok(trait_span, cx.expr_tuple(trait_span, vec![]));
+ let ret_ok = cx.expr(trait_span, ExprKind::Ret(Some(ok)));
stmts.push(cx.stmt_expr(ret_ok));
}
// expression; here add a layer of borrowing, turning
// `(*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 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
// if discriminant_test {
// expression; here add a layer of borrowing, turning
// `(*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 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)
}
}
};
let ident = cx.ident_of(&format!("{}_{}", prefix, i));
paths.push(codemap::Spanned{span: sp, node: ident});
- let val = cx.expr(
- sp, ast::ExprParen(cx.expr_deref(sp, cx.expr_path(cx.path_ident(sp,ident)))));
+ let val = 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[..]));
}
// as series of let's; the first approach does.
let pat = self.ecx.pat_tuple(self.fmtsp, pats);
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 args_slice = self.ecx.expr_addr_of(self.fmtsp, result);
projects / rust.git / commitdiff