Introduce the notion of deferred resolutions and use it to hold off on

doing the final checking for closure calls until after trait inference
is performed. This isn't important now, but it's essential if we are to
delay inferring the closure kind.

Author: nikomatsakis

src/librustc_typeck/check/_match.rs

@@ -30,7 +30,7 @@ use syntax::print::pprust;
 use syntax::ptr::P;
 
 pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
-                           pat: &ast::Pat,
+                           pat: &'tcx ast::Pat,
                            expected: Ty<'tcx>)
 {
     let fcx = pcx.fcx;
@@ -157,9 +157,10 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
         }
         ast::PatIdent(_, ref path, _) => {
             let path = ast_util::ident_to_path(path.span, path.node);
-            check_pat_enum(pcx, pat, &path, &Some(vec![]), expected);
+            check_pat_enum(pcx, pat, &path, Some(&[]), expected);
         }
         ast::PatEnum(ref path, ref subpats) => {
+            let subpats = subpats.as_ref().map(|v| &v[]);
             check_pat_enum(pcx, pat, path, subpats, expected);
         }
         ast::PatStruct(ref path, ref fields, etc) => {
@@ -335,9 +336,9 @@ pub fn check_dereferencable<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
 }
 
 pub fn check_match<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
-                             expr: &ast::Expr,
-                             discrim: &ast::Expr,
-                             arms: &[ast::Arm],
+                             expr: &'tcx ast::Expr,
+                             discrim: &'tcx ast::Expr,
+                             arms: &'tcx [ast::Arm],
                              expected: Expectation<'tcx>,
                              match_src: ast::MatchSource) {
     let tcx = fcx.ccx.tcx;
@@ -424,8 +425,8 @@ pub struct pat_ctxt<'a, 'tcx: 'a> {
     pub map: PatIdMap,
 }
 
-pub fn check_pat_struct<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &ast::Pat,
-                                  path: &ast::Path, fields: &[Spanned<ast::FieldPat>],
+pub fn check_pat_struct<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &'tcx ast::Pat,
+                                  path: &ast::Path, fields: &'tcx [Spanned<ast::FieldPat>],
                                   etc: bool, expected: Ty<'tcx>) {
     let fcx = pcx.fcx;
     let tcx = pcx.fcx.ccx.tcx;
@@ -483,10 +484,12 @@ pub fn check_pat_struct<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &ast::Pat,
                             variant_def_id, etc);
 }
 
-pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &ast::Pat,
-                                path: &ast::Path, subpats: &Option<Vec<P<ast::Pat>>>,
-                                expected: Ty<'tcx>) {
-
+pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
+                                pat: &ast::Pat,
+                                path: &ast::Path,
+                                subpats: Option<&'tcx [P<ast::Pat>]>,
+                                expected: Ty<'tcx>)
+{
     // Typecheck the path.
     let fcx = pcx.fcx;
     let tcx = pcx.fcx.ccx.tcx;
@@ -536,7 +539,7 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &ast::Pat,
                 "`{}` does not name a non-struct variant or a tuple struct", name);
             fcx.write_error(pat.id);
 
-            if let Some(ref subpats) = *subpats {
+            if let Some(subpats) = subpats {
                 for pat in subpats.iter() {
                     check_pat(pcx, &**pat, tcx.types.err);
                 }
@@ -545,7 +548,7 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &ast::Pat,
         }
     };
 
-    if let Some(ref subpats) = *subpats {
+    if let Some(subpats) = subpats {
         if subpats.len() == arg_tys.len() {
             for (subpat, arg_ty) in subpats.iter().zip(arg_tys.iter()) {
                 check_pat(pcx, &**subpat, *arg_ty);
@@ -579,7 +582,7 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &ast::Pat,
 /// `etc` is true if the pattern said '...' and false otherwise.
 pub fn check_struct_pat_fields<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
                                          span: Span,
-                                         fields: &[Spanned<ast::FieldPat>],
+                                         fields: &'tcx [Spanned<ast::FieldPat>],
                                          struct_fields: &[ty::field<'tcx>],
                                          struct_id: ast::DefId,
                                          etc: bool) {

src/librustc_typeck/check/callee.rs

@@ -13,6 +13,8 @@ use super::AutorefArgs;
 use super::check_argument_types;
 use super::check_expr;
 use super::check_method_argument_types;
+use super::demand;
+use super::DeferredResolution;
 use super::err_args;
 use super::Expectation;
 use super::expected_types_for_fn_args;
@@ -24,13 +26,14 @@ use super::TupleArgumentsFlag;
 use super::UnresolvedTypeAction;
 use super::write_call;
 
+use CrateCtxt;
 use middle::infer;
-use middle::ty::{self, Ty};
+use middle::ty::{self, Ty, ClosureTyper};
 use syntax::ast;
 use syntax::codemap::Span;
 use syntax::parse::token;
 use syntax::ptr::P;
-use CrateCtxt;
+use util::ppaux::Repr;
 
 /// Check that it is legal to call methods of the trait corresponding
 /// to `trait_id` (this only cares about the trait, not the specific
@@ -66,9 +69,9 @@ pub fn check_legal_trait_for_method_call(ccx: &CrateCtxt, span: Span, trait_id:
 }
 
 pub fn check_call<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
-                            call_expr: &ast::Expr,
-                            callee_expr: &ast::Expr,
-                            arg_exprs: &[P<ast::Expr>],
+                            call_expr: &'tcx ast::Expr,
+                            callee_expr: &'tcx ast::Expr,
+                            arg_exprs: &'tcx [P<ast::Expr>],
                             expected: Expectation<'tcx>)
 {
     check_expr(fcx, callee_expr);
@@ -96,24 +99,35 @@ pub fn check_call<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
             confirm_builtin_call(fcx, call_expr, callee_ty, arg_exprs, expected);
         }
 
+        Some(CallStep::Closure(fn_sig)) => {
+            confirm_closure_call(fcx, call_expr, arg_exprs, expected, fn_sig);
+        }
+
         Some(CallStep::Overloaded(method_callee)) => {
-            confirm_overloaded_call(fcx, call_expr, arg_exprs, method_callee, expected);
+            confirm_overloaded_call(fcx, call_expr, callee_expr,
+                                    arg_exprs, expected, method_callee);
         }
     }
 }
 
 enum CallStep<'tcx> {
     Builtin,
+    Closure(ty::FnSig<'tcx>),
     Overloaded(ty::MethodCallee<'tcx>)
 }
 
 fn try_overloaded_call_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
-                                      call_expr: &ast::Expr,
-                                      callee_expr: &ast::Expr,
+                                      call_expr: &'tcx ast::Expr,
+                                      callee_expr: &'tcx ast::Expr,
                                       adjusted_ty: Ty<'tcx>,
                                       autoderefref: ty::AutoDerefRef<'tcx>)
                                       -> Option<CallStep<'tcx>>
 {
+    debug!("try_overloaded_call_step(call_expr={}, adjusted_ty={}, autoderefref={})",
+           call_expr.repr(fcx.tcx()),
+           adjusted_ty.repr(fcx.tcx()),
+           autoderefref.repr(fcx.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(..) => {
@@ -123,9 +137,37 @@ fn try_overloaded_call_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
             return Some(CallStep::Builtin);
         }
 
+        ty::ty_closure(def_id, _, substs) => {
+            let closure_ty =
+                fcx.closure_type(def_id, substs);
+            let fn_sig =
+                fcx.infcx().replace_late_bound_regions_with_fresh_var(call_expr.span,
+                                                                      infer::FnCall,
+                                                                      &closure_ty.sig).0;
+            fcx.record_deferred_resolution(box CallResolution {
+                call_expr: call_expr,
+                callee_expr: callee_expr,
+                adjusted_ty: adjusted_ty,
+                autoderefref: autoderefref,
+                fn_sig: fn_sig.clone(),
+            });
+            return Some(CallStep::Closure(fn_sig));
+        }
+
         _ => {}
     }
 
+    try_overloaded_call_traits(fcx, call_expr, callee_expr, adjusted_ty, autoderefref)
+        .map(|method_callee| CallStep::Overloaded(method_callee))
+}
+
+fn try_overloaded_call_traits<'a,'tcx>(fcx: &FnCtxt<'a, 'tcx>,
+                                       call_expr: &ast::Expr,
+                                       callee_expr: &ast::Expr,
+                                       adjusted_ty: Ty<'tcx>,
+                                       autoderefref: ty::AutoDerefRef<'tcx>)
+                                       -> Option<ty::MethodCallee<'tcx>>
+{
     // 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")),
@@ -147,7 +189,7 @@ fn try_overloaded_call_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
                                                None) {
             None => continue,
             Some(method_callee) => {
-                return Some(CallStep::Overloaded(method_callee));
+                return Some(method_callee);
             }
         }
     }
@@ -158,7 +200,7 @@ fn try_overloaded_call_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
 fn confirm_builtin_call<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
                                  call_expr: &ast::Expr,
                                  callee_ty: Ty<'tcx>,
-                                 arg_exprs: &[P<ast::Expr>],
+                                 arg_exprs: &'tcx [P<ast::Expr>],
                                  expected: Expectation<'tcx>)
 {
     let error_fn_sig;
@@ -215,22 +257,124 @@ fn confirm_builtin_call<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
     write_call(fcx, call_expr, fn_sig.output);
 }
 
+fn confirm_closure_call<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
+                                 call_expr: &ast::Expr,
+                                 arg_exprs: &'tcx [P<ast::Expr>],
+                                 expected: Expectation<'tcx>,
+                                 fn_sig: ty::FnSig<'tcx>)
+{
+    // `fn_sig` is the *signature* of the cosure being called. We
+    // don't know the full details yet (`Fn` vs `FnMut` etc), but we
+    // do know the types expected for each argument and the return
+    // type.
+
+    let expected_arg_tys =
+        expected_types_for_fn_args(fcx,
+                                   call_expr.span,
+                                   expected,
+                                   fn_sig.output.clone(),
+                                   &*fn_sig.inputs);
+
+    check_argument_types(fcx,
+                         call_expr.span,
+                         &*fn_sig.inputs,
+                         &*expected_arg_tys,
+                         arg_exprs,
+                         AutorefArgs::No,
+                         fn_sig.variadic,
+                         TupleArgumentsFlag::TupleArguments);
+
+    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>,
-                                    expected: Expectation<'tcx>)
+                                    callee_expr: &'tcx ast::Expr,
+                                    arg_exprs: &'tcx [P<ast::Expr>],
+                                    expected: Expectation<'tcx>,
+                                    method_callee: ty::MethodCallee<'tcx>)
 {
-    let output_type = check_method_argument_types(fcx,
-                                                  call_expr.span,
-                                                  method_callee.ty,
-                                                  call_expr,
-                                                  arg_exprs,
-                                                  AutorefArgs::No,
-                                                  TupleArgumentsFlag::TupleArguments,
-                                                  expected);
+    let output_type =
+        check_method_argument_types(fcx,
+                                    call_expr.span,
+                                    method_callee.ty,
+                                    callee_expr,
+                                    arg_exprs,
+                                    AutorefArgs::No,
+                                    TupleArgumentsFlag::TupleArguments,
+                                    expected);
+    write_call(fcx, call_expr, output_type);
+
+    write_overloaded_call_method_map(fcx, call_expr, method_callee);
+}
+
+fn write_overloaded_call_method_map<'a,'tcx>(fcx: &FnCtxt<'a, 'tcx>,
+                                             call_expr: &ast::Expr,
+                                             method_callee: ty::MethodCallee<'tcx>) {
     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);
 }
 
+struct CallResolution<'tcx> {
+    call_expr: &'tcx ast::Expr,
+    callee_expr: &'tcx ast::Expr,
+    adjusted_ty: Ty<'tcx>,
+    autoderefref: ty::AutoDerefRef<'tcx>,
+    fn_sig: ty::FnSig<'tcx>,
+}
+
+impl<'tcx> Repr<'tcx> for CallResolution<'tcx> {
+    fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
+        format!("CallResolution(call_expr={}, callee_expr={}, adjusted_ty={}, \
+                autoderefref={}, fn_sig={})",
+                self.call_expr.repr(tcx),
+                self.callee_expr.repr(tcx),
+                self.adjusted_ty.repr(tcx),
+                self.autoderefref.repr(tcx),
+                self.fn_sig.repr(tcx))
+    }
+}
+
+impl<'tcx> DeferredResolution<'tcx> for CallResolution<'tcx> {
+    fn attempt_resolution<'a>(&self, fcx: &FnCtxt<'a,'tcx>) -> bool {
+        debug!("attempt_resolution() {}",
+               self.repr(fcx.tcx()));
+
+        // We may now know enough to figure out fn vs fnmut etc.
+        match try_overloaded_call_traits(fcx, self.call_expr, self.callee_expr,
+                                         self.adjusted_ty, self.autoderefref.clone()) {
+            None => false,
+            Some(method_callee) => {
+                // One problem is that when we get here, we are going
+                // to have a newly instantiated function signature
+                // from the call trait. This has to be reconciled with
+                // the older function signature we had before. In
+                // principle we *should* be able to fn_sigs(), but we
+                // can't because of the annoying need for a TypeTrace.
+                // (This always bites me, should find a way to
+                // refactor it.)
+                let method_sig =
+                    ty::assert_no_late_bound_regions(fcx.tcx(),
+                                                     ty::ty_fn_sig(method_callee.ty));
+
+                debug!("attempt_resolution: method_callee={}",
+                       method_callee.repr(fcx.tcx()));
+
+                for (&method_arg_ty, &self_arg_ty) in
+                    method_sig.inputs[1..].iter().zip(self.fn_sig.inputs.iter())
+                {
+                    demand::eqtype(fcx, self.call_expr.span, self_arg_ty, method_arg_ty);
+                }
+
+                demand::eqtype(fcx,
+                               self.call_expr.span,
+                               method_sig.output.unwrap(),
+                               self.fn_sig.output.unwrap());
+
+                write_overloaded_call_method_map(fcx, self.call_expr, method_callee);
+
+                true
+            }
+        }
+    }
+}

src/librustc_typeck/check/closure.rs

@@ -26,8 +26,8 @@ pub fn check_expr_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
                                    expr: &ast::Expr,
                                    _capture: ast::CaptureClause,
                                    opt_kind: Option<ast::ClosureKind>,
-                                   decl: &ast::FnDecl,
-                                   body: &ast::Block,
+                                   decl: &'tcx ast::FnDecl,
+                                   body: &'tcx ast::Block,
                                    expected: Expectation<'tcx>) {
     debug!("check_expr_closure(expr={},expected={})",
            expr.repr(fcx.tcx()),
@@ -76,8 +76,8 @@ pub fn check_expr_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
 fn check_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
                           expr: &ast::Expr,
                           kind: ty::ClosureKind,
-                          decl: &ast::FnDecl,
-                          body: &ast::Block,
+                          decl: &'tcx ast::FnDecl,
+                          body: &'tcx ast::Block,
                           expected_sig: Option<ty::FnSig<'tcx>>) {
     let expr_def_id = ast_util::local_def(expr.id);