From 11b2515f0f5a46cfe6ef55b623b028b8dbc59519 Mon Sep 17 00:00:00 2001 From: HeroesGrave Date: Fri, 14 Feb 2014 16:51:26 +1300 Subject: Removed libextra dependency from libsyntax. --- src/libsyntax/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index 613416bed1c..78e40a795db 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -32,7 +32,7 @@ This API is completely unstable and subject to change. #[deny(non_camel_case_types)]; -extern mod extra; +#[cfg(test)] extern mod extra; extern mod serialize; extern mod term; extern mod collections; -- cgit 1.4.1-3-g733a5 From 07ea23e15dab673a3016d21b601234b296e59e57 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Thu, 13 Feb 2014 22:57:43 -0800 Subject: Expand ItemDecorator extensions in all contexts Now that fold_item can return multiple items, this is pretty trivial. It also recursively expands generated items so ItemDecorators can generate items that are tagged with ItemDecorators! Closes #4913 --- src/libsyntax/ext/expand.rs | 85 ++++++++++++++----------------------- src/libsyntax/util/small_vector.rs | 8 +++- src/test/run-pass/deriving-in-fn.rs | 19 +++++++++ 3 files changed, 59 insertions(+), 53 deletions(-) create mode 100644 src/test/run-pass/deriving-in-fn.rs (limited to 'src/libsyntax') diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index e59afc6ffa6..97766e1a14b 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -203,52 +203,6 @@ pub fn expand_expr(e: @ast::Expr, fld: &mut MacroExpander) -> @ast::Expr { } } -// This is a secondary mechanism for invoking syntax extensions on items: -// "decorator" attributes, such as #[auto_encode]. These are invoked by an -// attribute prefixing an item, and are interpreted by feeding the item -// through the named attribute _as a syntax extension_ and splicing in the -// resulting item vec into place in favour of the decorator. Note that -// these do _not_ work for macro extensions, just ItemDecorator ones. -// -// NB: there is some redundancy between this and expand_item, below, and -// they might benefit from some amount of semantic and language-UI merger. -pub fn expand_mod_items(module_: &ast::Mod, fld: &mut MacroExpander) -> ast::Mod { - // Fold the contents first: - let module_ = noop_fold_mod(module_, fld); - - // For each item, look through the attributes. If any of them are - // decorated with "item decorators", then use that function to transform - // the item into a new set of items. - let mut new_items = module_.items.clone(); - for item in module_.items.iter() { - for attr in item.attrs.rev_iter() { - let mname = attr.name(); - - match fld.extsbox.find(&intern(mname.get())) { - Some(&ItemDecorator(dec_fn)) => { - fld.cx.bt_push(ExpnInfo { - call_site: attr.span, - callee: NameAndSpan { - name: mname.get().to_str(), - format: MacroAttribute, - span: None - } - }); - dec_fn(fld.cx, attr.span, attr.node.value, *item, - |item| new_items.push(item)); - fld.cx.bt_pop(); - }, - _ => {}, - } - } - } - - ast::Mod { - items: new_items, - ..module_ - } -} - // eval $e with a new exts frame: macro_rules! with_exts_frame ( ($extsboxexpr:expr,$macros_escape:expr,$e:expr) => @@ -263,7 +217,35 @@ macro_rules! with_exts_frame ( // When we enter a module, record it, for the sake of `module!` pub fn expand_item(it: @ast::Item, fld: &mut MacroExpander) -> SmallVector<@ast::Item> { - match it.node { + let mut decorator_items = SmallVector::zero(); + for attr in it.attrs.rev_iter() { + let mname = attr.name(); + + match fld.extsbox.find(&intern(mname.get())) { + Some(&ItemDecorator(dec_fn)) => { + fld.cx.bt_push(ExpnInfo { + call_site: attr.span, + callee: NameAndSpan { + name: mname.get().to_str(), + format: MacroAttribute, + span: None + } + }); + // we'd ideally decorator_items.push_all(expand_item(item, fld)), + // but that double-mut-borrows fld + dec_fn(fld.cx, attr.span, attr.node.value, it, + |item| decorator_items.push(item)); + fld.cx.bt_pop(); + } + _ => {} + } + } + + let decorator_items = decorator_items.move_iter() + .flat_map(|item| expand_item(item, fld).move_iter()) + .collect(); + + let mut new_items = match it.node { ast::ItemMac(..) => expand_item_mac(it, fld), ast::ItemMod(_) | ast::ItemForeignMod(_) => { fld.cx.mod_push(it.ident); @@ -275,7 +257,10 @@ pub fn expand_item(it: @ast::Item, fld: &mut MacroExpander) result }, _ => noop_fold_item(it, fld) - } + }; + + new_items.push_all(decorator_items); + new_items } // does this attribute list contain "macro_escape" ? @@ -778,10 +763,6 @@ impl<'a> Folder for MacroExpander<'a> { expand_expr(expr, self) } - fn fold_mod(&mut self, module: &ast::Mod) -> ast::Mod { - expand_mod_items(module, self) - } - fn fold_item(&mut self, item: @ast::Item) -> SmallVector<@ast::Item> { expand_item(item, self) } diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs index e0d7fdd8790..32e5b83ee04 100644 --- a/src/libsyntax/util/small_vector.rs +++ b/src/libsyntax/util/small_vector.rs @@ -1,4 +1,4 @@ -// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // @@ -64,6 +64,12 @@ impl SmallVector { } } + pub fn push_all(&mut self, other: SmallVector) { + for v in other.move_iter() { + self.push(v); + } + } + pub fn get<'a>(&'a self, idx: uint) -> &'a T { match *self { One(ref v) if idx == 0 => v, diff --git a/src/test/run-pass/deriving-in-fn.rs b/src/test/run-pass/deriving-in-fn.rs new file mode 100644 index 00000000000..7fb7d601b81 --- /dev/null +++ b/src/test/run-pass/deriving-in-fn.rs @@ -0,0 +1,19 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +pub fn main() { + #[deriving(ToStr)] + struct Foo { + foo: int, + } + + let f = Foo { foo: 10 }; + let _ = f.to_str(); +} -- cgit 1.4.1-3-g733a5 From 6e840235962ca579cb5aa5d90d82165890c79f4c Mon Sep 17 00:00:00 2001 From: Eduard Burtescu Date: Fri, 14 Feb 2014 10:28:32 +0200 Subject: Removed the obsolete ast::CallSugar (previously used by `do`). --- src/librustc/middle/borrowck/check_loans.rs | 4 +- src/librustc/middle/cfg/construct.rs | 4 +- src/librustc/middle/check_const.rs | 2 +- src/librustc/middle/dataflow.rs | 4 +- src/librustc/middle/effect.rs | 4 +- src/librustc/middle/liveness.rs | 4 +- src/librustc/middle/moves.rs | 4 +- src/librustc/middle/privacy.rs | 2 +- src/librustc/middle/resolve.rs | 2 +- src/librustc/middle/trans/consts.rs | 2 +- src/librustc/middle/trans/debuginfo.rs | 4 +- src/librustc/middle/trans/expr.rs | 4 +- src/librustc/middle/typeck/check/mod.rs | 69 ++++++++------------------- src/librustc/middle/typeck/check/regionck.rs | 4 +- src/librustc/middle/typeck/check/vtable.rs | 2 +- src/librustc/middle/typeck/check/writeback.rs | 2 +- src/libsyntax/ast.rs | 12 ++--- src/libsyntax/ext/build.rs | 7 ++- src/libsyntax/fold.rs | 11 ++--- src/libsyntax/parse/classify.rs | 16 +++---- src/libsyntax/parse/parser.rs | 14 +++--- src/libsyntax/print/pprust.rs | 44 ++++------------- src/libsyntax/visit.rs | 4 +- 23 files changed, 79 insertions(+), 146 deletions(-) (limited to 'src/libsyntax') diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs index 1f90d2d8f0f..590229a6652 100644 --- a/src/librustc/middle/borrowck/check_loans.rs +++ b/src/librustc/middle/borrowck/check_loans.rs @@ -831,10 +831,10 @@ fn check_loans_in_expr<'a>(this: &mut CheckLoanCtxt<'a>, ast::ExprAssignOp(_, _, dest, _) => { this.check_assignment(dest); } - ast::ExprCall(f, ref args, _) => { + ast::ExprCall(f, ref args) => { this.check_call(expr, Some(f), f.id, f.span, *args); } - ast::ExprMethodCall(callee_id, _, _, ref args, _) => { + ast::ExprMethodCall(callee_id, _, _, ref args) => { this.check_call(expr, None, callee_id, expr.span, *args); } ast::ExprIndex(callee_id, _, rval) | diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index 9c213558d9c..6ca779906e2 100644 --- a/src/librustc/middle/cfg/construct.rs +++ b/src/librustc/middle/cfg/construct.rs @@ -351,11 +351,11 @@ impl CFGBuilder { self.straightline(expr, pred, *elems) } - ast::ExprCall(func, ref args, _) => { + ast::ExprCall(func, ref args) => { self.call(expr, pred, func, *args) } - ast::ExprMethodCall(_, _, _, ref args, _) => { + ast::ExprMethodCall(_, _, _, ref args) => { self.call(expr, pred, args[0], args.slice_from(1)) } diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 88ade3e225a..75337a27a6c 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -160,7 +160,7 @@ pub fn check_expr(v: &mut CheckCrateVisitor, } } } - ExprCall(callee, _, NoSugar) => { + ExprCall(callee, _) => { let def_map = def_map.borrow(); match def_map.get().find(&callee.id) { Some(&DefStruct(..)) => {} // OK. diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index 4d22f541432..60d83d7559e 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -577,12 +577,12 @@ impl<'a, O:DataFlowOperator> PropagationContext<'a, O> { self.walk_opt_expr(with_expr, in_out, loop_scopes); } - ast::ExprCall(f, ref args, _) => { + ast::ExprCall(f, ref args) => { self.walk_expr(f, in_out, loop_scopes); self.walk_call(f.id, expr.id, *args, in_out, loop_scopes); } - ast::ExprMethodCall(callee_id, _, _, ref args, _) => { + ast::ExprMethodCall(callee_id, _, _, ref args) => { self.walk_call(callee_id, expr.id, *args, in_out, loop_scopes); } diff --git a/src/librustc/middle/effect.rs b/src/librustc/middle/effect.rs index 1445d5734ad..2a40c8148fd 100644 --- a/src/librustc/middle/effect.rs +++ b/src/librustc/middle/effect.rs @@ -120,7 +120,7 @@ impl Visitor<()> for EffectCheckVisitor { fn visit_expr(&mut self, expr: &ast::Expr, _:()) { match expr.node { - ast::ExprMethodCall(callee_id, _, _, _, _) => { + ast::ExprMethodCall(callee_id, _, _, _) => { let base_type = ty::node_id_to_type(self.tcx, callee_id); debug!("effect: method call case, base type is {}", ppaux::ty_to_str(self.tcx, base_type)); @@ -129,7 +129,7 @@ impl Visitor<()> for EffectCheckVisitor { "invocation of unsafe method") } } - ast::ExprCall(base, _, _) => { + ast::ExprCall(base, _) => { let base_type = ty::node_id_to_type(self.tcx, base.id); debug!("effect: call case, base type is {}", ppaux::ty_to_str(self.tcx, base_type)); diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index b7a89db4b9e..70b5aab4c93 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -1205,7 +1205,7 @@ impl Liveness { }) } - ExprCall(f, ref args, _) => { + ExprCall(f, ref args) => { // calling a fn with bot return type means that the fn // will fail, and hence the successors can be ignored let t_ret = ty::ty_fn_ret(ty::expr_ty(self.tcx, f)); @@ -1215,7 +1215,7 @@ impl Liveness { self.propagate_through_expr(f, succ) } - ExprMethodCall(callee_id, _, _, ref args, _) => { + ExprMethodCall(callee_id, _, _, ref args) => { // calling a method with bot return type means that the method // will fail, and hence the successors can be ignored let t_ret = ty::ty_fn_ret(ty::node_id_to_type(self.tcx, callee_id)); diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs index a0dc8634792..32cb7ca57da 100644 --- a/src/librustc/middle/moves.rs +++ b/src/librustc/middle/moves.rs @@ -382,7 +382,7 @@ impl VisitContext { } } - ExprCall(callee, ref args, _) => { // callee(args) + ExprCall(callee, ref args) => { // callee(args) // Figure out whether the called function is consumed. let mode = match ty::get(ty::expr_ty(self.tcx, callee)).sty { ty::ty_closure(ref cty) => { @@ -412,7 +412,7 @@ impl VisitContext { self.use_fn_args(callee.id, *args); } - ExprMethodCall(callee_id, _, _, ref args, _) => { // callee.m(args) + ExprMethodCall(callee_id, _, _, ref args) => { // callee.m(args) self.use_fn_args(callee_id, *args); } diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index 1f3bb2ba70d..8c5654d3fce 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -705,7 +705,7 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> { _ => {} } } - ast::ExprMethodCall(_, ident, _, ref args, _) => { + ast::ExprMethodCall(_, ident, _, ref args) => { // see above let t = ty::type_autoderef(ty::expr_ty(self.tcx, args[0])); match ty::get(t).sty { diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index bedaff70121..cb9e772dcea 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -5221,7 +5221,7 @@ impl Resolver { let traits = self.search_for_traits_containing_method(ident); self.trait_map.insert(expr.id, @RefCell::new(traits)); } - ExprMethodCall(_, ident, _, _, _) => { + ExprMethodCall(_, ident, _, _) => { debug!("(recording candidate traits for expr) recording \ traits for {}", expr.id); diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs index 9c04f6d9399..68be851449a 100644 --- a/src/librustc/middle/trans/consts.rs +++ b/src/librustc/middle/trans/consts.rs @@ -647,7 +647,7 @@ fn const_expr_unadjusted(cx: @CrateContext, e: &ast::Expr, } } } - ast::ExprCall(callee, ref args, _) => { + ast::ExprCall(callee, ref args) => { let tcx = cx.tcx; let opt_def = { let def_map = tcx.def_map.borrow(); diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index 74450695ae7..86f4275cf98 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -2624,7 +2624,7 @@ fn populate_scope_map(cx: &CrateContext, }) } - ast::ExprCall(fn_exp, ref args, _) => { + ast::ExprCall(fn_exp, ref args) => { walk_expr(cx, fn_exp, scope_stack, scope_map); for arg_exp in args.iter() { @@ -2632,7 +2632,7 @@ fn populate_scope_map(cx: &CrateContext, } } - ast::ExprMethodCall(node_id, _, _, ref args, _) => { + ast::ExprMethodCall(node_id, _, _, ref args) => { scope_map.insert(node_id, scope_stack.last().unwrap().scope_metadata); for arg_exp in args.iter() { diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 357e2e5e9ef..794964e1054 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -777,11 +777,11 @@ fn trans_rvalue_dps_unadjusted<'a>(bcx: &'a Block<'a>, expr_to_str(expr), expr_ty.repr(tcx)); closure::trans_expr_fn(bcx, sigil, decl, body, expr.id, dest) } - ast::ExprCall(f, ref args, _) => { + ast::ExprCall(f, ref args) => { callee::trans_call(bcx, expr, f, callee::ArgExprs(*args), expr.id, dest) } - ast::ExprMethodCall(callee_id, _, _, ref args, _) => { + ast::ExprMethodCall(callee_id, _, _, ref args) => { callee::trans_method_call(bcx, expr, callee_id, args[0], callee::ArgExprs(*args), dest) } diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index 5d33f6d1722..177eba5aa1b 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -1592,22 +1592,20 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt, method_fn_ty: ty::t, callee_expr: &ast::Expr, args: &[@ast::Expr], - sugar: ast::CallSugar, - deref_args: DerefArgs) -> ty::t - { + deref_args: DerefArgs) -> ty::t { // HACK(eddyb) ignore provided self (it has special typeck rules). let args = args.slice_from(1); if ty::type_is_error(method_fn_ty) { let err_inputs = err_args(args.len()); check_argument_types(fcx, sp, err_inputs, callee_expr, - args, sugar, deref_args, false); + args, deref_args, false); method_fn_ty } else { match ty::get(method_fn_ty).sty { ty::ty_bare_fn(ref fty) => { // HACK(eddyb) ignore self in the definition (see above). check_argument_types(fcx, sp, fty.sig.inputs.slice_from(1), - callee_expr, args, sugar, deref_args, + callee_expr, args, deref_args, fty.sig.variadic); fty.sig.output } @@ -1625,7 +1623,6 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt, fn_inputs: &[ty::t], callee_expr: &ast::Expr, args: &[@ast::Expr], - sugar: ast::CallSugar, deref_args: DerefArgs, variadic: bool) { /*! @@ -1659,18 +1656,12 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt, err_args(supplied_arg_count) } } else { - let suffix = match sugar { - ast::NoSugar => "", - ast::ForSugar => " (including the closure passed by \ - the `for` keyword)" - }; let msg = format!( "this function takes {} parameter{} \ - but {} parameter{} supplied{}", + but {} parameter{} supplied", expected_arg_count, if expected_arg_count == 1 {""} else {"s"}, supplied_arg_count, - if supplied_arg_count == 1 {" was"} else {"s were"}, - suffix); + if supplied_arg_count == 1 {" was"} else {"s were"}); tcx.sess.span_err(sp, msg); @@ -1783,24 +1774,8 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt, // The callee checks for bot / err, we don't need to } - fn write_call(fcx: @FnCtxt, - call_expr: &ast::Expr, - output: ty::t, - sugar: ast::CallSugar) { - let ret_ty = match sugar { - ast::ForSugar => { - match ty::get(output).sty { - ty::ty_bool => {} - _ => fcx.type_error_message(call_expr.span, |actual| { - format!("expected `for` closure to return `bool`, \ - but found `{}`", actual) }, - output, None) - } - ty::mk_nil() - } - _ => output - }; - fcx.write_ty(call_expr.id, ret_ty); + fn write_call(fcx: @FnCtxt, call_expr: &ast::Expr, output: ty::t) { + fcx.write_ty(call_expr.id, output); } // A generic function for doing all of the checking for call expressions @@ -1808,8 +1783,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt, callee_id: ast::NodeId, call_expr: &ast::Expr, f: &ast::Expr, - args: &[@ast::Expr], - sugar: ast::CallSugar) { + args: &[@ast::Expr]) { // Index expressions need to be handled separately, to inform them // that they appear in call position. check_expr(fcx, f); @@ -1857,9 +1831,9 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt, // Call the generic checker. check_argument_types(fcx, call_expr.span, fn_sig.inputs, f, - args, sugar, DontDerefArgs, fn_sig.variadic); + args, DontDerefArgs, fn_sig.variadic); - write_call(fcx, call_expr, fn_sig.output, sugar); + write_call(fcx, call_expr, fn_sig.output); } // Checks a method call. @@ -1868,8 +1842,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt, expr: &ast::Expr, method_name: ast::Ident, args: &[@ast::Expr], - tps: &[ast::P], - sugar: ast::CallSugar) { + tps: &[ast::P]) { let rcvr = args[0]; check_expr(fcx, rcvr); @@ -1915,10 +1888,10 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt, // Call the generic checker. let fn_ty = fcx.node_ty(callee_id); let ret_ty = check_method_argument_types(fcx, expr.span, - fn_ty, expr, args, sugar, + fn_ty, expr, args, DontDerefArgs); - write_call(fcx, expr, ret_ty, sugar); + write_call(fcx, expr, ret_ty); } // A generic function for checking the then and else in an if @@ -1985,8 +1958,8 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt, method_map.get().insert(op_ex.id, *origin); } check_method_argument_types(fcx, op_ex.span, - method_ty, op_ex, args, - ast::NoSugar, deref_args) + method_ty, op_ex, + args, deref_args) } _ => { unbound_method(); @@ -1994,8 +1967,8 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt, // so we get all the error messages let expected_ty = ty::mk_err(); check_method_argument_types(fcx, op_ex.span, - expected_ty, op_ex, args, - ast::NoSugar, deref_args); + expected_ty, op_ex, + args, deref_args); ty::mk_err() } } @@ -2948,8 +2921,8 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt, check_block_with_expected(fcx, b, expected); fcx.write_ty(id, fcx.node_ty(b.id)); } - ast::ExprCall(f, ref args, sugar) => { - check_call(fcx, expr.id, expr, f, *args, sugar); + ast::ExprCall(f, ref args) => { + check_call(fcx, expr.id, expr, f, *args); let f_ty = fcx.expr_ty(f); let (args_bot, args_err) = args.iter().fold((false, false), |(rest_bot, rest_err), a| { @@ -2964,8 +2937,8 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt, fcx.write_bot(id); } } - ast::ExprMethodCall(callee_id, ident, ref tps, ref args, sugar) => { - check_method_call(fcx, callee_id, expr, ident, *args, *tps, sugar); + ast::ExprMethodCall(callee_id, ident, ref tps, ref args) => { + check_method_call(fcx, callee_id, expr, ident, *args, *tps); let arg_tys = args.map(|a| fcx.expr_ty(*a)); let (args_bot, args_err) = arg_tys.iter().fold((false, false), |(rest_bot, rest_err), a| { diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index a015f43b230..38400772778 100644 --- a/src/librustc/middle/typeck/check/regionck.rs +++ b/src/librustc/middle/typeck/check/regionck.rs @@ -432,14 +432,14 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) { } match expr.node { - ast::ExprCall(callee, ref args, _) => { + ast::ExprCall(callee, ref args) => { constrain_callee(rcx, callee.id, expr, callee); constrain_call(rcx, callee.id, expr, None, *args, false); visit::walk_expr(rcx, expr, ()); } - ast::ExprMethodCall(callee_id, _, _, ref args, _) => { + ast::ExprMethodCall(callee_id, _, _, ref args) => { constrain_call(rcx, callee_id, expr, Some(args[0]), args.slice_from(1), false); diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs index 46e79f4d1d5..721672ab677 100644 --- a/src/librustc/middle/typeck/check/vtable.rs +++ b/src/librustc/middle/typeck/check/vtable.rs @@ -702,7 +702,7 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: @FnCtxt, is_early: bool) { ast::ExprUnary(callee_id, _, _) | ast::ExprAssignOp(callee_id, _, _, _) | ast::ExprIndex(callee_id, _, _) | - ast::ExprMethodCall(callee_id, _, _, _, _) => { + ast::ExprMethodCall(callee_id, _, _, _) => { match ty::method_call_type_param_defs(cx.tcx, fcx.inh.method_map, ex.id) { Some(type_param_defs) => { debug!("vtable resolution on parameter bounds for method call {}", diff --git a/src/librustc/middle/typeck/check/writeback.rs b/src/librustc/middle/typeck/check/writeback.rs index 36abb7aa457..c05afcf859a 100644 --- a/src/librustc/middle/typeck/check/writeback.rs +++ b/src/librustc/middle/typeck/check/writeback.rs @@ -307,7 +307,7 @@ fn visit_expr(e: &ast::Expr, wbcx: &mut WbCtxt) { maybe_resolve_type_vars_for_node(wbcx, e.span, callee_id); } - ast::ExprMethodCall(callee_id, _, _, _, _) => { + ast::ExprMethodCall(callee_id, _, _, _) => { // We must always have written in a callee ID type for these. resolve_type_vars_for_node(wbcx, e.span, callee_id); } diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 72330bb7f31..132cb396ddd 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -519,7 +519,7 @@ pub struct Expr { impl Expr { pub fn get_callee_id(&self) -> Option { match self.node { - ExprMethodCall(callee_id, _, _, _, _) | + ExprMethodCall(callee_id, _, _, _) | ExprIndex(callee_id, _, _) | ExprBinary(callee_id, _, _, _) | ExprAssignOp(callee_id, _, _, _) | @@ -529,20 +529,14 @@ impl Expr { } } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] -pub enum CallSugar { - NoSugar, - ForSugar -} - #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] pub enum Expr_ { ExprVstore(@Expr, ExprVstore), // First expr is the place; second expr is the value. ExprBox(@Expr, @Expr), ExprVec(~[@Expr], Mutability), - ExprCall(@Expr, ~[@Expr], CallSugar), - ExprMethodCall(NodeId, Ident, ~[P], ~[@Expr], CallSugar), + ExprCall(@Expr, ~[@Expr]), + ExprMethodCall(NodeId, Ident, ~[P], ~[@Expr]), ExprTup(~[@Expr]), ExprBinary(NodeId, BinOp, @Expr, @Expr), ExprUnary(NodeId, UnOp, @Expr), diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index e41decbd8ef..d311a542ac6 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -525,11 +525,10 @@ impl<'a> AstBuilder for ExtCtxt<'a> { } fn expr_call(&self, span: Span, expr: @ast::Expr, args: ~[@ast::Expr]) -> @ast::Expr { - self.expr(span, ast::ExprCall(expr, args, ast::NoSugar)) + self.expr(span, ast::ExprCall(expr, args)) } fn expr_call_ident(&self, span: Span, id: ast::Ident, args: ~[@ast::Expr]) -> @ast::Expr { - self.expr(span, - ast::ExprCall(self.expr_ident(span, id), args, ast::NoSugar)) + self.expr(span, ast::ExprCall(self.expr_ident(span, id), args)) } fn expr_call_global(&self, sp: Span, fn_path: ~[ast::Ident], args: ~[@ast::Expr]) -> @ast::Expr { @@ -541,7 +540,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> { ident: ast::Ident, mut args: ~[@ast::Expr]) -> @ast::Expr { args.unshift(expr); - self.expr(span, ast::ExprMethodCall(ast::DUMMY_NODE_ID, ident, ~[], args, ast::NoSugar)) + self.expr(span, ast::ExprMethodCall(ast::DUMMY_NODE_ID, ident, ~[], args)) } fn expr_block(&self, b: P) -> @ast::Expr { self.expr(b.span, ast::ExprBlock(b)) diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 6fb66a66f18..e150d1685de 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -727,19 +727,16 @@ pub fn noop_fold_expr(e: @Expr, folder: &mut T) -> @Expr { ExprRepeat(folder.fold_expr(expr), folder.fold_expr(count), mutt) } ExprTup(ref elts) => ExprTup(elts.map(|x| folder.fold_expr(*x))), - ExprCall(f, ref args, blk) => { + ExprCall(f, ref args) => { ExprCall(folder.fold_expr(f), - args.map(|&x| folder.fold_expr(x)), - blk) + args.map(|&x| folder.fold_expr(x))) } - ExprMethodCall(callee_id, i, ref tps, ref args, blk) => { + ExprMethodCall(callee_id, i, ref tps, ref args) => { ExprMethodCall( folder.new_id(callee_id), folder.fold_ident(i), tps.map(|&x| folder.fold_ty(x)), - args.map(|&x| folder.fold_expr(x)), - blk - ) + args.map(|&x| folder.fold_expr(x))) } ExprBinary(callee_id, binop, lhs, rhs) => { ExprBinary(folder.new_id(callee_id), diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs index accf5e73540..d6dcb956f25 100644 --- a/src/libsyntax/parse/classify.rs +++ b/src/libsyntax/parse/classify.rs @@ -23,15 +23,13 @@ use ast; // 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::ExprMatch(..) - | ast::ExprBlock(_) - | ast::ExprWhile(..) - | ast::ExprLoop(..) - | ast::ExprForLoop(..) - | ast::ExprCall(_, _, ast::ForSugar) - | ast::ExprMethodCall(_, _, _, _, ast::ForSugar) => false, - _ => true + ast::ExprIf(..) + | ast::ExprMatch(..) + | ast::ExprBlock(_) + | ast::ExprWhile(..) + | ast::ExprLoop(..) + | ast::ExprForLoop(..) => false, + _ => true } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 674d41e9dbe..a02971ae8ea 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -13,7 +13,6 @@ use abi; use abi::AbiSet; use ast::{Sigil, BorrowedSigil, ManagedSigil, OwnedSigil}; -use ast::{CallSugar, NoSugar}; use ast::{BareFnTy, ClosureTy}; use ast::{RegionTyParamBound, TraitTyParamBound}; use ast::{Provided, Public, Purity}; @@ -1690,13 +1689,12 @@ impl Parser { ExprBinary(ast::DUMMY_NODE_ID, binop, lhs, rhs) } - pub fn mk_call(&mut self, f: @Expr, args: ~[@Expr], sugar: CallSugar) -> ast::Expr_ { - ExprCall(f, args, sugar) + pub fn mk_call(&mut self, f: @Expr, args: ~[@Expr]) -> ast::Expr_ { + ExprCall(f, args) } - fn mk_method_call(&mut self, ident: Ident, tps: ~[P], args: ~[@Expr], - sugar: CallSugar) -> ast::Expr_ { - ExprMethodCall(ast::DUMMY_NODE_ID, ident, tps, args, sugar) + fn mk_method_call(&mut self, ident: Ident, tps: ~[P], args: ~[@Expr]) -> ast::Expr_ { + ExprMethodCall(ast::DUMMY_NODE_ID, ident, tps, args) } pub fn mk_index(&mut self, expr: @Expr, idx: @Expr) -> ast::Expr_ { @@ -1997,7 +1995,7 @@ impl Parser { hi = self.last_span.hi; es.unshift(e); - let nd = self.mk_method_call(i, tys, es, NoSugar); + let nd = self.mk_method_call(i, tys, es); e = self.mk_expr(lo, hi, nd); } _ => { @@ -2022,7 +2020,7 @@ impl Parser { ); hi = self.last_span.hi; - let nd = self.mk_call(e, es, NoSugar); + let nd = self.mk_call(e, es); e = self.mk_expr(lo, hi, nd); } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 85bc372b9c6..bb2f345ac28 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1141,33 +1141,10 @@ pub fn print_expr_vstore(s: &mut State, t: ast::ExprVstore) -> io::IoResult<()> } } -pub fn print_call_pre(s: &mut State, - sugar: ast::CallSugar, - base_args: &mut ~[@ast::Expr]) - -> io::IoResult> { - match sugar { - ast::ForSugar => { - if_ok!(head(s, "for")); - Ok(Some(base_args.pop().unwrap())) - } - ast::NoSugar => Ok(None) - } -} - -pub fn print_call_post(s: &mut State, - sugar: ast::CallSugar, - blk: &Option<@ast::Expr>, - base_args: &mut ~[@ast::Expr]) -> io::IoResult<()> { - if sugar == ast::NoSugar || !base_args.is_empty() { - if_ok!(popen(s)); - if_ok!(commasep_exprs(s, Inconsistent, *base_args)); - if_ok!(pclose(s)); - } - if sugar != ast::NoSugar { - if_ok!(nbsp(s)); - // not sure if this can happen - if_ok!(print_expr(s, blk.unwrap())); - } +fn print_call_post(s: &mut State, args: &[@ast::Expr]) -> io::IoResult<()> { + if_ok!(popen(s)); + if_ok!(commasep_exprs(s, Inconsistent, args)); + if_ok!(pclose(s)); Ok(()) } @@ -1254,15 +1231,12 @@ pub fn print_expr(s: &mut State, expr: &ast::Expr) -> io::IoResult<()> { } if_ok!(pclose(s)); } - ast::ExprCall(func, ref args, sugar) => { - let mut base_args = (*args).clone(); - let blk = if_ok!(print_call_pre(s, sugar, &mut base_args)); + ast::ExprCall(func, ref args) => { if_ok!(print_expr(s, func)); - if_ok!(print_call_post(s, sugar, &blk, &mut base_args)); + if_ok!(print_call_post(s, *args)); } - ast::ExprMethodCall(_, ident, ref tys, ref args, sugar) => { - let mut base_args = args.slice_from(1).to_owned(); - let blk = if_ok!(print_call_pre(s, sugar, &mut base_args)); + ast::ExprMethodCall(_, ident, ref tys, ref args) => { + let base_args = args.slice_from(1); if_ok!(print_expr(s, args[0])); if_ok!(word(&mut s.s, ".")); if_ok!(print_ident(s, ident)); @@ -1271,7 +1245,7 @@ pub fn print_expr(s: &mut State, expr: &ast::Expr) -> io::IoResult<()> { if_ok!(commasep(s, Inconsistent, *tys, print_type_ref)); if_ok!(word(&mut s.s, ">")); } - if_ok!(print_call_post(s, sugar, &blk, &mut base_args)); + if_ok!(print_call_post(s, base_args)); } ast::ExprBinary(_, op, lhs, rhs) => { if_ok!(print_expr(s, lhs)); diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index ce87c3d7591..feab4e0e84d 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -652,13 +652,13 @@ pub fn walk_expr>(visitor: &mut V, expression: &Expr, en visitor.visit_expr(*subexpression, env.clone()) } } - ExprCall(callee_expression, ref arguments, _) => { + ExprCall(callee_expression, ref arguments) => { for argument in arguments.iter() { visitor.visit_expr(*argument, env.clone()) } visitor.visit_expr(callee_expression, env.clone()) } - ExprMethodCall(_, _, ref types, ref arguments, _) => { + ExprMethodCall(_, _, ref types, ref arguments) => { walk_exprs(visitor, *arguments, env.clone()); for &typ in types.iter() { visitor.visit_ty(typ, env.clone()) -- cgit 1.4.1-3-g733a5