src/librustc_typeck/check/callee.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use super::{Expectation, FnCtxt, Needs, TupleArgumentsFlag};
  12 use super::autoderef::Autoderef;
  13 use super::method::MethodCallee;
  14
  15 use hir::def::Def;
  16 use hir::def_id::{DefId, LOCAL_CRATE};
  17 use rustc::{infer, traits};
  18 use rustc::ty::{self, TyCtxt, TypeFoldable, Ty};
  19 use rustc::ty::adjustment::{Adjustment, Adjust, AutoBorrow};
  20 use syntax::abi;
  21 use syntax::symbol::Symbol;
  22 use syntax_pos::Span;
  23
  24 use rustc::hir;
  25
  26 /// Check that it is legal to call methods of the trait corresponding
  27 /// to `trait_id` (this only cares about the trait, not the specific
  28 /// method that is called)
  29 pub fn check_legal_trait_for_method_call(tcx: TyCtxt, span: Span, trait_id: DefId) {
  30     if tcx.lang_items().drop_trait() == Some(trait_id) {
  31         struct_span_err!(tcx.sess, span, E0040, "explicit use of destructor method")
  32             .span_label(span, "explicit destructor calls not allowed")
  33             .emit();
  34     }
  35 }
  36
  37 enum CallStep<'tcx> {
  38     Builtin(Ty<'tcx>),
  39     DeferredClosure(ty::FnSig<'tcx>),
  40     /// e.g. enum variant constructors
  41     Overloaded(MethodCallee<'tcx>),
  42 }
  43
  44 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
  45     pub fn check_call(&self,
  46                       call_expr: &'gcx hir::Expr,
  47                       callee_expr: &'gcx hir::Expr,
  48                       arg_exprs: &'gcx [hir::Expr],
  49                       expected: Expectation<'tcx>)
  50                       -> Ty<'tcx> {
  51         let original_callee_ty = self.check_expr(callee_expr);
  52         let expr_ty = self.structurally_resolved_type(call_expr.span, original_callee_ty);
  53
  54         let mut autoderef = self.autoderef(callee_expr.span, expr_ty);
  55         let mut result = None;
  56         while result.is_none() && autoderef.next().is_some() {
  57             result = self.try_overloaded_call_step(call_expr, callee_expr, &autoderef);
  58         }
  59         autoderef.finalize();
  60
  61         let output = match result {
  62             None => {
  63                 // this will report an error since original_callee_ty is not a fn
  64                 self.confirm_builtin_call(call_expr, original_callee_ty, arg_exprs, expected)
  65             }
  66
  67             Some(CallStep::Builtin(callee_ty)) => {
  68                 self.confirm_builtin_call(call_expr, callee_ty, arg_exprs, expected)
  69             }
  70
  71             Some(CallStep::DeferredClosure(fn_sig)) => {
  72                 self.confirm_deferred_closure_call(call_expr, arg_exprs, expected, fn_sig)
  73             }
  74
  75             Some(CallStep::Overloaded(method_callee)) => {
  76                 self.confirm_overloaded_call(call_expr, arg_exprs, expected, method_callee)
  77             }
  78         };
  79
  80         // we must check that return type of called functions is WF:
  81         self.register_wf_obligation(output, call_expr.span, traits::MiscObligation);
  82
  83         output
  84     }
  85
  86     fn try_overloaded_call_step(&self,
  87                                 call_expr: &'gcx hir::Expr,
  88                                 callee_expr: &'gcx hir::Expr,
  89                                 autoderef: &Autoderef<'a, 'gcx, 'tcx>)
  90                                 -> Option<CallStep<'tcx>> {
  91         let adjusted_ty = autoderef.unambiguous_final_ty();
  92         debug!("try_overloaded_call_step(call_expr={:?}, adjusted_ty={:?})",
  93                call_expr,
  94                adjusted_ty);
  95
  96         // If the callee is a bare function or a closure, then we're all set.
  97         match adjusted_ty.sty {
  98             ty::TyFnDef(..) | ty::TyFnPtr(_) => {
  99                 let adjustments = autoderef.adjust_steps(Needs::None);
 100                 self.apply_adjustments(callee_expr, adjustments);
 101                 return Some(CallStep::Builtin(adjusted_ty));
 102             }
 103
 104             ty::TyClosure(def_id, substs) => {
 105                 assert_eq!(def_id.krate, LOCAL_CRATE);
 106
 107                 // Check whether this is a call to a closure where we
 108                 // haven't yet decided on whether the closure is fn vs
 109                 // fnmut vs fnonce. If so, we have to defer further processing.
 110                 if self.closure_kind(def_id, substs).is_none() {
 111                     let closure_ty = self.closure_sig(def_id, substs);
 112                     let fn_sig = self.replace_late_bound_regions_with_fresh_var(call_expr.span,
 113                                                                    infer::FnCall,
 114                                                                    &closure_ty)
 115                         .0;
 116                     let adjustments = autoderef.adjust_steps(Needs::None);
 117                     self.record_deferred_call_resolution(def_id, DeferredCallResolution {
 118                         call_expr,
 119                         callee_expr,
 120                         adjusted_ty,
 121                         adjustments,
 122                         fn_sig,
 123                         closure_def_id: def_id,
 124                         closure_substs: substs,
 125                     });
 126                     return Some(CallStep::DeferredClosure(fn_sig));
 127                 }
 128             }
 129
 130             // Hack: we know that there are traits implementing Fn for &F
 131             // where F:Fn and so forth. In the particular case of types
 132             // like `x: &mut FnMut()`, if there is a call `x()`, we would
 133             // normally translate to `FnMut::call_mut(&mut x, ())`, but
 134             // that winds up requiring `mut x: &mut FnMut()`. A little
 135             // over the top. The simplest fix by far is to just ignore
 136             // this case and deref again, so we wind up with
 137             // `FnMut::call_mut(&mut *x, ())`.
 138             ty::TyRef(..) if autoderef.step_count() == 0 => {
 139                 return None;
 140             }
 141
 142             _ => {}
 143         }
 144
 145         self.try_overloaded_call_traits(call_expr, adjusted_ty).map(|(autoref, method)| {
 146             let mut adjustments = autoderef.adjust_steps(Needs::None);
 147             adjustments.extend(autoref);
 148             self.apply_adjustments(callee_expr, adjustments);
 149             CallStep::Overloaded(method)
 150         })
 151     }
 152
 153     fn try_overloaded_call_traits(&self,
 154                                   call_expr: &hir::Expr,
 155                                   adjusted_ty: Ty<'tcx>)
 156                                   -> Option<(Option<Adjustment<'tcx>>,
 157                                              MethodCallee<'tcx>)> {
 158         // Try the options that are least restrictive on the caller first.
 159         for &(opt_trait_def_id, method_name, borrow) in
 160             &[(self.tcx.lang_items().fn_trait(), Symbol::intern("call"), true),
 161               (self.tcx.lang_items().fn_mut_trait(), Symbol::intern("call_mut"), true),
 162               (self.tcx.lang_items().fn_once_trait(), Symbol::intern("call_once"), false)] {
 163             let trait_def_id = match opt_trait_def_id {
 164                 Some(def_id) => def_id,
 165                 None => continue,
 166             };
 167
 168             match self.lookup_method_in_trait(call_expr.span,
 169                                               method_name,
 170                                               trait_def_id,
 171                                               adjusted_ty,
 172                                               None) {
 173                 None => continue,
 174                 Some(ok) => {
 175                     let method = self.register_infer_ok_obligations(ok);
 176                     let mut autoref = None;
 177                     if borrow {
 178                         if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
 179                             autoref = Some(Adjustment {
 180                                 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
 181                                 target: method.sig.inputs()[0]
 182                             });
 183                         }
 184                     }
 185                     return Some((autoref, method));
 186                 }
 187             }
 188         }
 189
 190         None
 191     }
 192
 193     fn confirm_builtin_call(&self,
 194                             call_expr: &hir::Expr,
 195                             callee_ty: Ty<'tcx>,
 196                             arg_exprs: &'gcx [hir::Expr],
 197                             expected: Expectation<'tcx>)
 198                             -> Ty<'tcx> {
 199         let (fn_sig, def_span) = match callee_ty.sty {
 200             ty::TyFnDef(def_id, _) => {
 201                 (callee_ty.fn_sig(self.tcx), self.tcx.hir.span_if_local(def_id))
 202             }
 203             ty::TyFnPtr(sig) => (sig, None),
 204             ref t => {
 205                 let mut unit_variant = None;
 206                 if let &ty::TyAdt(adt_def, ..) = t {
 207                     if adt_def.is_enum() {
 208                         if let hir::ExprCall(ref expr, _) = call_expr.node {
 209                             unit_variant = Some(self.tcx.hir.node_to_pretty_string(expr.id))
 210                         }
 211                     }
 212                 }
 213
 214                 let mut err = type_error_struct!(
 215                     self.tcx.sess,
 216                     call_expr.span,
 217                     callee_ty,
 218                     E0618,
 219                     "expected function, found {}",
 220                     match unit_variant {
 221                         Some(ref path) => format!("enum variant `{}`", path),
 222                         None => format!("`{}`", callee_ty),
 223                     });
 224
 225                 err.span_label(call_expr.span, "not a function");
 226
 227                 if let Some(ref path) = unit_variant {
 228                     err.span_suggestion(call_expr.span,
 229                                         &format!("`{}` is a unit variant, you need to write it \
 230                                                   without the parenthesis", path),
 231                                         path.to_string());
 232                 }
 233
 234                 if let hir::ExprCall(ref expr, _) = call_expr.node {
 235                     let def = if let hir::ExprPath(ref qpath) = expr.node {
 236                         self.tables.borrow().qpath_def(qpath, expr.hir_id)
 237                     } else {
 238                         Def::Err
 239                     };
 240                     let def_span = match def {
 241                         Def::Err => None,
 242                         Def::Local(id) | Def::Upvar(id, ..) => {
 243                             Some(self.tcx.hir.span(id))
 244                         }
 245                         _ => self.tcx.hir.span_if_local(def.def_id())
 246                     };
 247                     if let Some(span) = def_span {
 248                         let name = match unit_variant {
 249                             Some(path) => path,
 250                             None => callee_ty.to_string(),
 251                         };
 252                         err.span_label(span, format!("`{}` defined here", name));
 253                     }
 254                 }
 255
 256                 err.emit();
 257
 258                 // This is the "default" function signature, used in case of error.
 259                 // In that case, we check each argument against "error" in order to
 260                 // set up all the node type bindings.
 261                 (ty::Binder(self.tcx.mk_fn_sig(
 262                     self.err_args(arg_exprs.len()).into_iter(),
 263                     self.tcx.types.err,
 264                     false,
 265                     hir::Unsafety::Normal,
 266                     abi::Abi::Rust
 267                 )), None)
 268             }
 269         };
 270
 271         // Replace any late-bound regions that appear in the function
 272         // signature with region variables. We also have to
 273         // renormalize the associated types at this point, since they
 274         // previously appeared within a `Binder<>` and hence would not
 275         // have been normalized before.
 276         let fn_sig =
 277             self.replace_late_bound_regions_with_fresh_var(call_expr.span, infer::FnCall, &fn_sig)
 278                 .0;
 279         let fn_sig = self.normalize_associated_types_in(call_expr.span, &fn_sig);
 280
 281         // Call the generic checker.
 282         let expected_arg_tys =
 283             self.expected_inputs_for_expected_output(call_expr.span,
 284                                             expected,
 285                                             fn_sig.output(),
 286                                             fn_sig.inputs());
 287         self.check_argument_types(call_expr.span,
 288                                   call_expr.span,
 289                                   fn_sig.inputs(),
 290                                   &expected_arg_tys[..],
 291                                   arg_exprs,
 292                                   fn_sig.variadic,
 293                                   TupleArgumentsFlag::DontTupleArguments,
 294                                   def_span);
 295
 296         fn_sig.output()
 297     }
 298
 299     fn confirm_deferred_closure_call(&self,
 300                                      call_expr: &hir::Expr,
 301                                      arg_exprs: &'gcx [hir::Expr],
 302                                      expected: Expectation<'tcx>,
 303                                      fn_sig: ty::FnSig<'tcx>)
 304                                      -> Ty<'tcx> {
 305         // `fn_sig` is the *signature* of the cosure being called. We
 306         // don't know the full details yet (`Fn` vs `FnMut` etc), but we
 307         // do know the types expected for each argument and the return
 308         // type.
 309
 310         let expected_arg_tys = self.expected_inputs_for_expected_output(call_expr.span,
 311                                                                expected,
 312                                                                fn_sig.output().clone(),
 313                                                                fn_sig.inputs());
 314
 315         self.check_argument_types(call_expr.span,
 316                                   call_expr.span,
 317                                   fn_sig.inputs(),
 318                                   &expected_arg_tys,
 319                                   arg_exprs,
 320                                   fn_sig.variadic,
 321                                   TupleArgumentsFlag::TupleArguments,
 322                                   None);
 323
 324         fn_sig.output()
 325     }
 326
 327     fn confirm_overloaded_call(&self,
 328                                call_expr: &hir::Expr,
 329                                arg_exprs: &'gcx [hir::Expr],
 330                                expected: Expectation<'tcx>,
 331                                method_callee: MethodCallee<'tcx>)
 332                                -> Ty<'tcx> {
 333         let output_type = self.check_method_argument_types(call_expr.span,
 334                                                            call_expr.span,
 335                                                            Ok(method_callee),
 336                                                            arg_exprs,
 337                                                            TupleArgumentsFlag::TupleArguments,
 338                                                            expected);
 339
 340         self.write_method_call(call_expr.hir_id, method_callee);
 341         output_type
 342     }
 343 }
 344
 345 #[derive(Debug)]
 346 pub struct DeferredCallResolution<'gcx: 'tcx, 'tcx> {
 347     call_expr: &'gcx hir::Expr,
 348     callee_expr: &'gcx hir::Expr,
 349     adjusted_ty: Ty<'tcx>,
 350     adjustments: Vec<Adjustment<'tcx>>,
 351     fn_sig: ty::FnSig<'tcx>,
 352     closure_def_id: DefId,
 353     closure_substs: ty::ClosureSubsts<'tcx>,
 354 }
 355
 356 impl<'a, 'gcx, 'tcx> DeferredCallResolution<'gcx, 'tcx> {
 357     pub fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) {
 358         debug!("DeferredCallResolution::resolve() {:?}", self);
 359
 360         // we should not be invoked until the closure kind has been
 361         // determined by upvar inference
 362         assert!(fcx.closure_kind(self.closure_def_id, self.closure_substs).is_some());
 363
 364         // We may now know enough to figure out fn vs fnmut etc.
 365         match fcx.try_overloaded_call_traits(self.call_expr,
 366                                              self.adjusted_ty) {
 367             Some((autoref, method_callee)) => {
 368                 // One problem is that when we get here, we are going
 369                 // to have a newly instantiated function signature
 370                 // from the call trait. This has to be reconciled with
 371                 // the older function signature we had before. In
 372                 // principle we *should* be able to fn_sigs(), but we
 373                 // can't because of the annoying need for a TypeTrace.
 374                 // (This always bites me, should find a way to
 375                 // refactor it.)
 376                 let method_sig = method_callee.sig;
 377
 378                 debug!("attempt_resolution: method_callee={:?}", method_callee);
 379
 380                 for (method_arg_ty, self_arg_ty) in
 381                     method_sig.inputs().iter().skip(1).zip(self.fn_sig.inputs()) {
 382                     fcx.demand_eqtype(self.call_expr.span, &self_arg_ty, &method_arg_ty);
 383                 }
 384
 385                 fcx.demand_eqtype(self.call_expr.span, method_sig.output(), self.fn_sig.output());
 386
 387                 let mut adjustments = self.adjustments;
 388                 adjustments.extend(autoref);
 389                 fcx.apply_adjustments(self.callee_expr, adjustments);
 390
 391                 fcx.write_method_call(self.call_expr.hir_id,
 392                                       method_callee);
 393             }
 394             None => {
 395                 span_bug!(self.call_expr.span,
 396                           "failed to find an overloaded call trait for closure call");
 397             }
 398         }
 399     }
 400 }