---

yaml
---
r: 168765
b: refs/heads/snap-stage3
c: 71cdf76
h: refs/heads/master
i:
  168763: 2ee3020
v: v3

Author: nikomatsakis

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 5e21e17d9638d14af41e27e5ca9a21c8a1bc0170
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 260e46115b922d29ca98b3cbea190011b1d3e63f
+refs/heads/snap-stage3: 71cdf7624054dafebc05ae59cbd6b2a11cd39287
 refs/heads/try: 5204084bd2e46af7cc6e0147430e44dd0d657bbb
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/librustc/middle/cfg/construct.rs

@@ -509,7 +509,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
         let method_call = ty::MethodCall::expr(call_expr.id);
         let return_ty = ty::ty_fn_ret(match self.tcx.method_map.borrow().get(&method_call) {
             Some(method) => method.ty,
-            None => ty::expr_ty_adjusted(self.tcx, func_or_rcvr)
+            None => ty::expr_ty(self.tcx, func_or_rcvr)
         });
 
         let func_or_rcvr_exit = self.expr(func_or_rcvr, pred);

branches/snap-stage3/src/librustc/middle/liveness.rs

@@ -1149,7 +1149,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
 
           ast::ExprCall(ref f, ref args) => {
             let diverges = !self.ir.tcx.is_method_call(expr.id) && {
-                let t_ret = ty::ty_fn_ret(ty::expr_ty_adjusted(self.ir.tcx, &**f));
+                let t_ret = ty::ty_fn_ret(ty::expr_ty(self.ir.tcx, &**f));
                 t_ret == ty::FnDiverging
             };
             let succ = if diverges {

branches/snap-stage3/src/librustc/middle/ty_fold.rs

@@ -70,6 +70,13 @@ pub trait TypeFolder<'tcx> : Sized {
     /// track the Debruijn index nesting level.
     fn exit_region_binder(&mut self) { }
 
+    fn fold_binder<T>(&mut self, t: &ty::Binder<T>) -> ty::Binder<T>
+        where T : TypeFoldable<'tcx> + Repr<'tcx>
+    {
+        // TODO this should eventually replace `enter_region_binder`/`exit_region_binder` altogether.
+        super_fold_binder(self, t)
+    }
+
     fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
         super_fold_ty(self, t)
     }
@@ -183,12 +190,9 @@ impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for Vec<T> {
     }
 }
 
-impl<'tcx, T:TypeFoldable<'tcx>> TypeFoldable<'tcx> for ty::Binder<T> {
+impl<'tcx, T:TypeFoldable<'tcx>+Repr<'tcx>> TypeFoldable<'tcx> for ty::Binder<T> {
     fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::Binder<T> {
-        folder.enter_region_binder();
-        let result = ty::Binder(self.0.fold_with(folder));
-        folder.exit_region_binder();
-        result
+        folder.fold_binder(self)
     }
 }
 
@@ -556,6 +560,17 @@ impl<'tcx> TypeFoldable<'tcx> for ty::UnboxedClosureUpvar<'tcx> {
 //
 // They should invoke `foo.fold_with()` to do recursive folding.
 
+pub fn super_fold_binder<'tcx, T, U>(this: &mut T,
+                                     binder: &ty::Binder<U>)
+                                     -> ty::Binder<U>
+    where T : TypeFolder<'tcx>, U : TypeFoldable<'tcx>
+{
+    this.enter_region_binder();
+    let result = ty::Binder(binder.0.fold_with(this));
+    this.exit_region_binder();
+    result
+}
+
 pub fn super_fold_ty<'tcx, T: TypeFolder<'tcx>>(this: &mut T,
                                                 ty: Ty<'tcx>)
                                                 -> Ty<'tcx> {

branches/snap-stage3/src/librustc_trans/trans/callee.rs

@@ -576,7 +576,7 @@ pub fn trans_call<'a, 'blk, 'tcx>(in_cx: Block<'blk, 'tcx>,
     let _icx = push_ctxt("trans_call");
     trans_call_inner(in_cx,
                      Some(common::expr_info(call_ex)),
-                     expr_ty_adjusted(in_cx, f),
+                     expr_ty(in_cx, f),
                      |cx, _| trans(cx, f),
                      args,
                      Some(dest)).bcx

branches/snap-stage3/src/librustc_typeck/check/callee.rs

@@ -8,25 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use super::autoderef;
-use super::AutorefArgs;
-use super::check_argument_types;
-use super::check_expr;
-use super::check_method_argument_types;
-use super::err_args;
-use super::FnCtxt;
-use super::LvaluePreference;
-use super::method;
-use super::structurally_resolved_type;
-use super::TupleArgumentsFlag;
-use super::write_call;
-
-use middle::infer;
-use middle::ty::{mod, Ty};
 use syntax::ast;
 use syntax::codemap::Span;
-use syntax::parse::token;
-use syntax::ptr::P;
 use CrateCtxt;
 
 /// Check that it is legal to call methods of the trait corresponding
@@ -61,165 +44,3 @@ pub fn check_legal_trait_for_method_call(ccx: &CrateCtxt, span: Span, trait_id:
                    "add `#![feature(unboxed_closures)]` to the crate attributes to enable");
     }
 }
-
-pub fn check_call<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
-                            call_expr: &ast::Expr,
-                            callee_expr: &ast::Expr,
-                            arg_exprs: &[P<ast::Expr>])
-{
-    check_expr(fcx, callee_expr);
-    let original_callee_ty = fcx.expr_ty(callee_expr);
-    let (callee_ty, _, result) =
-        autoderef(fcx,
-                  callee_expr.span,
-                  original_callee_ty,
-                  Some(callee_expr.id),
-                  LvaluePreference::NoPreference,
-                  |adj_ty, idx| {
-                      let autoderefref = ty::AutoDerefRef { autoderefs: idx, autoref: None };
-                      try_overloaded_call_step(fcx, call_expr, callee_expr,
-                                               adj_ty, autoderefref)
-                  });
-
-    match result {
-        None => {
-            // this will report an error since original_callee_ty is not a fn
-            confirm_builtin_call(fcx, call_expr, original_callee_ty, arg_exprs);
-        }
-
-        Some(CallStep::Builtin) => {
-            confirm_builtin_call(fcx, call_expr, callee_ty, arg_exprs);
-        }
-
-        Some(CallStep::Overloaded(method_callee)) => {
-            confirm_overloaded_call(fcx, call_expr, arg_exprs, method_callee);
-        }
-    }
-}
-
-enum CallStep<'tcx> {
-    Builtin,
-    Overloaded(ty::MethodCallee<'tcx>)
-}
-
-fn try_overloaded_call_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
-                                      call_expr: &ast::Expr,
-                                      callee_expr: &ast::Expr,
-                                      adjusted_ty: Ty<'tcx>,
-                                      autoderefref: ty::AutoDerefRef<'tcx>)
-                                      -> Option<CallStep<'tcx>>
-{
-    // If the callee is a bare function or a closure, then we're all set.
-    match structurally_resolved_type(fcx, callee_expr.span, adjusted_ty).sty {
-        ty::ty_bare_fn(..) | ty::ty_closure(_) => {
-            fcx.write_adjustment(callee_expr.id,
-                                 callee_expr.span,
-                                 ty::AdjustDerefRef(autoderefref));
-            return Some(CallStep::Builtin);
-        }
-
-        _ => {}
-    }
-
-    // Try the options that are least restrictive on the caller first.
-    for &(opt_trait_def_id, method_name) in [
-        (fcx.tcx().lang_items.fn_trait(), token::intern("call")),
-        (fcx.tcx().lang_items.fn_mut_trait(), token::intern("call_mut")),
-        (fcx.tcx().lang_items.fn_once_trait(), token::intern("call_once")),
-    ].iter() {
-        let trait_def_id = match opt_trait_def_id {
-            Some(def_id) => def_id,
-            None => continue,
-        };
-
-        match method::lookup_in_trait_adjusted(fcx,
-                                               call_expr.span,
-                                               Some(&*callee_expr),
-                                               method_name,
-                                               trait_def_id,
-                                               autoderefref.clone(),
-                                               adjusted_ty,
-                                               None) {
-            None => continue,
-            Some(method_callee) => {
-                return Some(CallStep::Overloaded(method_callee));
-            }
-        }
-    }
-
-    None
-}
-
-fn confirm_builtin_call<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
-                                 call_expr: &ast::Expr,
-                                 callee_ty: Ty<'tcx>,
-                                 arg_exprs: &[P<ast::Expr>])
-{
-    let error_fn_sig;
-
-    let fn_sig = match callee_ty.sty {
-        ty::ty_bare_fn(_, &ty::BareFnTy {ref sig, ..}) |
-        ty::ty_closure(box ty::ClosureTy {ref sig, ..}) => {
-            sig
-        }
-        _ => {
-            fcx.type_error_message(call_expr.span, |actual| {
-                format!("expected function, found `{}`", actual)
-            }, callee_ty, None);
-
-            // This is the "default" function signature, used in case of error.
-            // In that case, we check each argument against "error" in order to
-            // set up all the node type bindings.
-            error_fn_sig = ty::Binder(ty::FnSig {
-                inputs: err_args(fcx.tcx(), arg_exprs.len()),
-                output: ty::FnConverging(fcx.tcx().types.err),
-                variadic: false
-            });
-
-            &error_fn_sig
-        }
-    };
-
-    // Replace any late-bound regions that appear in the function
-    // signature with region variables. We also have to
-    // renormalize the associated types at this point, since they
-    // previously appeared within a `Binder<>` and hence would not
-    // have been normalized before.
-    let fn_sig =
-        fcx.infcx().replace_late_bound_regions_with_fresh_var(call_expr.span,
-                                                              infer::FnCall,
-                                                              fn_sig).0;
-    let fn_sig =
-        fcx.normalize_associated_types_in(call_expr.span, &fn_sig);
-
-    // Call the generic checker.
-    let arg_exprs: Vec<_> = arg_exprs.iter().collect(); // for some weird reason we take &[&P<...>].
-    check_argument_types(fcx,
-                         call_expr.span,
-                         fn_sig.inputs[],
-                         arg_exprs.as_slice(),
-                         AutorefArgs::No,
-                         fn_sig.variadic,
-                         TupleArgumentsFlag::DontTupleArguments);
-
-    write_call(fcx, call_expr, fn_sig.output);
-}
-
-fn confirm_overloaded_call<'a,'tcx>(fcx: &FnCtxt<'a, 'tcx>,
-                                    call_expr: &ast::Expr,
-                                    arg_exprs: &[P<ast::Expr>],
-                                    method_callee: ty::MethodCallee<'tcx>)
-{
-    let arg_exprs: Vec<_> = arg_exprs.iter().collect(); // for some weird reason we take &[&P<...>].
-    let output_type = check_method_argument_types(fcx,
-                                                  call_expr.span,
-                                                  method_callee.ty,
-                                                  call_expr,
-                                                  arg_exprs.as_slice(),
-                                                  AutorefArgs::No,
-                                                  TupleArgumentsFlag::TupleArguments);
-    let method_call = ty::MethodCall::expr(call_expr.id);
-    fcx.inh.method_map.borrow_mut().insert(method_call, method_callee);
-    write_call(fcx, call_expr, output_type);
-}
-