crates/ra_hir_ty/src/infer/expr.rs

   1 //! Type inference for expressions.
   2
   3 use std::iter::{repeat, repeat_with};
   4 use std::sync::Arc;
   5
   6 use hir_def::{
   7     builtin_type::Signedness,
   8     expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
   9     path::{GenericArg, GenericArgs},
  10     resolver::resolver_for_expr,
  11     AdtId, AssocContainerId, Lookup, StructFieldId,
  12 };
  13 use hir_expand::name::{name, Name};
  14 use ra_syntax::ast::RangeOp;
  15
  16 use crate::{
  17     autoderef,
  18     db::HirDatabase,
  19     method_resolution, op,
  20     traits::InEnvironment,
  21     utils::{generics, variant_data, Generics},
  22     ApplicationTy, CallableDef, InferTy, IntTy, Mutability, Obligation, Substs, TraitRef, Ty,
  23     TypeCtor, TypeWalk, Uncertain,
  24 };
  25
  26 use super::{BindingMode, Expectation, InferenceContext, InferenceDiagnostic, TypeMismatch};
  27
  28 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
  29     pub(super) fn infer_expr(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
  30         let ty = self.infer_expr_inner(tgt_expr, expected);
  31         let could_unify = self.unify(&ty, &expected.ty);
  32         if !could_unify {
  33             self.result.type_mismatches.insert(
  34                 tgt_expr,
  35                 TypeMismatch { expected: expected.ty.clone(), actual: ty.clone() },
  36             );
  37         }
  38         let ty = self.resolve_ty_as_possible(ty);
  39         ty
  40     }
  41
  42     /// Infer type of expression with possibly implicit coerce to the expected type.
  43     /// Return the type after possible coercion.
  44     fn infer_expr_coerce(&mut self, expr: ExprId, expected: &Expectation) -> Ty {
  45         let ty = self.infer_expr_inner(expr, &expected);
  46         let ty = if !self.coerce(&ty, &expected.ty) {
  47             self.result
  48                 .type_mismatches
  49                 .insert(expr, TypeMismatch { expected: expected.ty.clone(), actual: ty.clone() });
  50             // Return actual type when type mismatch.
  51             // This is needed for diagnostic when return type mismatch.
  52             ty
  53         } else if expected.ty == Ty::Unknown {
  54             ty
  55         } else {
  56             expected.ty.clone()
  57         };
  58
  59         self.resolve_ty_as_possible(ty)
  60     }
  61
  62     fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
  63         let body = Arc::clone(&self.body); // avoid borrow checker problem
  64         let ty = match &body[tgt_expr] {
  65             Expr::Missing => Ty::Unknown,
  66             Expr::If { condition, then_branch, else_branch } => {
  67                 // if let is desugared to match, so this is always simple if
  68                 self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeCtor::Bool)));
  69
  70                 let then_ty = self.infer_expr_inner(*then_branch, &expected);
  71                 let else_ty = match else_branch {
  72                     Some(else_branch) => self.infer_expr_inner(*else_branch, &expected),
  73                     None => Ty::unit(),
  74                 };
  75
  76                 self.coerce_merge_branch(&then_ty, &else_ty)
  77             }
  78             Expr::Block { statements, tail } => self.infer_block(statements, *tail, expected),
  79             Expr::TryBlock { body } => {
  80                 let _inner = self.infer_expr(*body, expected);
  81                 // FIXME should be std::result::Result<{inner}, _>
  82                 Ty::Unknown
  83             }
  84             Expr::Loop { body } => {
  85                 self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
  86                 // FIXME handle break with value
  87                 Ty::simple(TypeCtor::Never)
  88             }
  89             Expr::While { condition, body } => {
  90                 // while let is desugared to a match loop, so this is always simple while
  91                 self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeCtor::Bool)));
  92                 self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
  93                 Ty::unit()
  94             }
  95             Expr::For { iterable, body, pat } => {
  96                 let iterable_ty = self.infer_expr(*iterable, &Expectation::none());
  97
  98                 let pat_ty =
  99                     self.resolve_associated_type(iterable_ty, self.resolve_into_iter_item());
 100
 101                 self.infer_pat(*pat, &pat_ty, BindingMode::default());
 102                 self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
 103                 Ty::unit()
 104             }
 105             Expr::Lambda { body, args, ret_type, arg_types } => {
 106                 assert_eq!(args.len(), arg_types.len());
 107
 108                 let mut sig_tys = Vec::new();
 109
 110                 for (arg_pat, arg_type) in args.iter().zip(arg_types.iter()) {
 111                     let expected = if let Some(type_ref) = arg_type {
 112                         self.make_ty(type_ref)
 113                     } else {
 114                         Ty::Unknown
 115                     };
 116                     let arg_ty = self.infer_pat(*arg_pat, &expected, BindingMode::default());
 117                     sig_tys.push(arg_ty);
 118                 }
 119
 120                 // add return type
 121                 let ret_ty = match ret_type {
 122                     Some(type_ref) => self.make_ty(type_ref),
 123                     None => self.table.new_type_var(),
 124                 };
 125                 sig_tys.push(ret_ty.clone());
 126                 let sig_ty = Ty::apply(
 127                     TypeCtor::FnPtr { num_args: sig_tys.len() as u16 - 1 },
 128                     Substs(sig_tys.into()),
 129                 );
 130                 let closure_ty = Ty::apply_one(
 131                     TypeCtor::Closure { def: self.owner.into(), expr: tgt_expr },
 132                     sig_ty,
 133                 );
 134
 135                 // Eagerly try to relate the closure type with the expected
 136                 // type, otherwise we often won't have enough information to
 137                 // infer the body.
 138                 self.coerce(&closure_ty, &expected.ty);
 139
 140                 let prev_ret_ty = std::mem::replace(&mut self.return_ty, ret_ty.clone());
 141
 142                 self.infer_expr_coerce(*body, &Expectation::has_type(ret_ty));
 143
 144                 self.return_ty = prev_ret_ty;
 145
 146                 closure_ty
 147             }
 148             Expr::Call { callee, args } => {
 149                 let callee_ty = self.infer_expr(*callee, &Expectation::none());
 150                 let (param_tys, ret_ty) = match callee_ty.callable_sig(self.db) {
 151                     Some(sig) => (sig.params().to_vec(), sig.ret().clone()),
 152                     None => {
 153                         // Not callable
 154                         // FIXME: report an error
 155                         (Vec::new(), Ty::Unknown)
 156                     }
 157                 };
 158                 self.register_obligations_for_call(&callee_ty);
 159                 self.check_call_arguments(args, &param_tys);
 160                 let ret_ty = self.normalize_associated_types_in(ret_ty);
 161                 ret_ty
 162             }
 163             Expr::MethodCall { receiver, args, method_name, generic_args } => self
 164                 .infer_method_call(tgt_expr, *receiver, &args, &method_name, generic_args.as_ref()),
 165             Expr::Match { expr, arms } => {
 166                 let input_ty = self.infer_expr(*expr, &Expectation::none());
 167
 168                 let mut result_ty = self.table.new_maybe_never_type_var();
 169
 170                 for arm in arms {
 171                     for &pat in &arm.pats {
 172                         let _pat_ty = self.infer_pat(pat, &input_ty, BindingMode::default());
 173                     }
 174                     if let Some(guard_expr) = arm.guard {
 175                         self.infer_expr(
 176                             guard_expr,
 177                             &Expectation::has_type(Ty::simple(TypeCtor::Bool)),
 178                         );
 179                     }
 180
 181                     let arm_ty = self.infer_expr_inner(arm.expr, &expected);
 182                     result_ty = self.coerce_merge_branch(&result_ty, &arm_ty);
 183                 }
 184
 185                 result_ty
 186             }
 187             Expr::Path(p) => {
 188                 // FIXME this could be more efficient...
 189                 let resolver = resolver_for_expr(self.db, self.owner.into(), tgt_expr);
 190                 self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown)
 191             }
 192             Expr::Continue => Ty::simple(TypeCtor::Never),
 193             Expr::Break { expr } => {
 194                 if let Some(expr) = expr {
 195                     // FIXME handle break with value
 196                     self.infer_expr(*expr, &Expectation::none());
 197                 }
 198                 Ty::simple(TypeCtor::Never)
 199             }
 200             Expr::Return { expr } => {
 201                 if let Some(expr) = expr {
 202                     self.infer_expr_coerce(*expr, &Expectation::has_type(self.return_ty.clone()));
 203                 } else {
 204                     let unit = Ty::unit();
 205                     self.coerce(&unit, &self.return_ty.clone());
 206                 }
 207                 Ty::simple(TypeCtor::Never)
 208             }
 209             Expr::RecordLit { path, fields, spread } => {
 210                 let (ty, def_id) = self.resolve_variant(path.as_ref());
 211                 if let Some(variant) = def_id {
 212                     self.write_variant_resolution(tgt_expr.into(), variant);
 213                 }
 214
 215                 self.unify(&ty, &expected.ty);
 216
 217                 let substs = ty.substs().unwrap_or_else(Substs::empty);
 218                 let field_types =
 219                     def_id.map(|it| self.db.field_types(it.into())).unwrap_or_default();
 220                 let variant_data = def_id.map(|it| variant_data(self.db, it));
 221                 for (field_idx, field) in fields.iter().enumerate() {
 222                     let field_def =
 223                         variant_data.as_ref().and_then(|it| match it.field(&field.name) {
 224                             Some(local_id) => {
 225                                 Some(StructFieldId { parent: def_id.unwrap(), local_id })
 226                             }
 227                             None => {
 228                                 self.push_diagnostic(InferenceDiagnostic::NoSuchField {
 229                                     expr: tgt_expr,
 230                                     field: field_idx,
 231                                 });
 232                                 None
 233                             }
 234                         });
 235                     if let Some(field_def) = field_def {
 236                         self.result.record_field_resolutions.insert(field.expr, field_def);
 237                     }
 238                     let field_ty = field_def
 239                         .map_or(Ty::Unknown, |it| field_types[it.local_id].clone())
 240                         .subst(&substs);
 241                     self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty));
 242                 }
 243                 if let Some(expr) = spread {
 244                     self.infer_expr(*expr, &Expectation::has_type(ty.clone()));
 245                 }
 246                 ty
 247             }
 248             Expr::Field { expr, name } => {
 249                 let receiver_ty = self.infer_expr_inner(*expr, &Expectation::none());
 250                 let canonicalized = self.canonicalizer().canonicalize_ty(receiver_ty);
 251                 let ty = autoderef::autoderef(
 252                     self.db,
 253                     self.resolver.krate(),
 254                     InEnvironment {
 255                         value: canonicalized.value.clone(),
 256                         environment: self.trait_env.clone(),
 257                     },
 258                 )
 259                 .find_map(|derefed_ty| match canonicalized.decanonicalize_ty(derefed_ty.value) {
 260                     Ty::Apply(a_ty) => match a_ty.ctor {
 261                         TypeCtor::Tuple { .. } => name
 262                             .as_tuple_index()
 263                             .and_then(|idx| a_ty.parameters.0.get(idx).cloned()),
 264                         TypeCtor::Adt(AdtId::StructId(s)) => {
 265                             self.db.struct_data(s).variant_data.field(name).map(|local_id| {
 266                                 let field = StructFieldId { parent: s.into(), local_id }.into();
 267                                 self.write_field_resolution(tgt_expr, field);
 268                                 self.db.field_types(s.into())[field.local_id]
 269                                     .clone()
 270                                     .subst(&a_ty.parameters)
 271                             })
 272                         }
 273                         // FIXME:
 274                         TypeCtor::Adt(AdtId::UnionId(_)) => None,
 275                         _ => None,
 276                     },
 277                     _ => None,
 278                 })
 279                 .unwrap_or(Ty::Unknown);
 280                 let ty = self.insert_type_vars(ty);
 281                 self.normalize_associated_types_in(ty)
 282             }
 283             Expr::Await { expr } => {
 284                 let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
 285                 let ty =
 286                     self.resolve_associated_type(inner_ty, self.resolve_future_future_output());
 287                 ty
 288             }
 289             Expr::Try { expr } => {
 290                 let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
 291                 let ty = self.resolve_associated_type(inner_ty, self.resolve_ops_try_ok());
 292                 ty
 293             }
 294             Expr::Cast { expr, type_ref } => {
 295                 let _inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
 296                 let cast_ty = self.make_ty(type_ref);
 297                 // FIXME check the cast...
 298                 cast_ty
 299             }
 300             Expr::Ref { expr, mutability } => {
 301                 let expectation =
 302                     if let Some((exp_inner, exp_mutability)) = &expected.ty.as_reference() {
 303                         if *exp_mutability == Mutability::Mut && *mutability == Mutability::Shared {
 304                             // FIXME: throw type error - expected mut reference but found shared ref,
 305                             // which cannot be coerced
 306                         }
 307                         Expectation::has_type(Ty::clone(exp_inner))
 308                     } else {
 309                         Expectation::none()
 310                     };
 311                 let inner_ty = self.infer_expr_inner(*expr, &expectation);
 312                 Ty::apply_one(TypeCtor::Ref(*mutability), inner_ty)
 313             }
 314             Expr::Box { expr } => {
 315                 let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
 316                 if let Some(box_) = self.resolve_boxed_box() {
 317                     Ty::apply_one(TypeCtor::Adt(box_), inner_ty)
 318                 } else {
 319                     Ty::Unknown
 320                 }
 321             }
 322             Expr::UnaryOp { expr, op } => {
 323                 let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
 324                 match op {
 325                     UnaryOp::Deref => match self.resolver.krate() {
 326                         Some(krate) => {
 327                             let canonicalized = self.canonicalizer().canonicalize_ty(inner_ty);
 328                             match autoderef::deref(
 329                                 self.db,
 330                                 krate,
 331                                 InEnvironment {
 332                                     value: &canonicalized.value,
 333                                     environment: self.trait_env.clone(),
 334                                 },
 335                             ) {
 336                                 Some(derefed_ty) => {
 337                                     canonicalized.decanonicalize_ty(derefed_ty.value)
 338                                 }
 339                                 None => Ty::Unknown,
 340                             }
 341                         }
 342                         None => Ty::Unknown,
 343                     },
 344                     UnaryOp::Neg => {
 345                         match &inner_ty {
 346                             // Fast path for builtins
 347                             Ty::Apply(ApplicationTy {
 348                                 ctor:
 349                                     TypeCtor::Int(Uncertain::Known(IntTy {
 350                                         signedness: Signedness::Signed,
 351                                         ..
 352                                     })),
 353                                 ..
 354                             })
 355                             | Ty::Apply(ApplicationTy {
 356                                 ctor: TypeCtor::Int(Uncertain::Unknown),
 357                                 ..
 358                             })
 359                             | Ty::Apply(ApplicationTy { ctor: TypeCtor::Float(_), .. })
 360                             | Ty::Infer(InferTy::IntVar(..))
 361                             | Ty::Infer(InferTy::FloatVar(..)) => inner_ty,
 362                             // Otherwise we resolve via the std::ops::Neg trait
 363                             _ => self
 364                                 .resolve_associated_type(inner_ty, self.resolve_ops_neg_output()),
 365                         }
 366                     }
 367                     UnaryOp::Not => {
 368                         match &inner_ty {
 369                             // Fast path for builtins
 370                             Ty::Apply(ApplicationTy { ctor: TypeCtor::Bool, .. })
 371                             | Ty::Apply(ApplicationTy { ctor: TypeCtor::Int(_), .. })
 372                             | Ty::Infer(InferTy::IntVar(..)) => inner_ty,
 373                             // Otherwise we resolve via the std::ops::Not trait
 374                             _ => self
 375                                 .resolve_associated_type(inner_ty, self.resolve_ops_not_output()),
 376                         }
 377                     }
 378                 }
 379             }
 380             Expr::BinaryOp { lhs, rhs, op } => match op {
 381                 Some(op) => {
 382                     let lhs_expectation = match op {
 383                         BinaryOp::LogicOp(..) => Expectation::has_type(Ty::simple(TypeCtor::Bool)),
 384                         _ => Expectation::none(),
 385                     };
 386                     let lhs_ty = self.infer_expr(*lhs, &lhs_expectation);
 387                     // FIXME: find implementation of trait corresponding to operation
 388                     // symbol and resolve associated `Output` type
 389                     let rhs_expectation = op::binary_op_rhs_expectation(*op, lhs_ty);
 390                     let rhs_ty = self.infer_expr(*rhs, &Expectation::has_type(rhs_expectation));
 391
 392                     // FIXME: similar as above, return ty is often associated trait type
 393                     op::binary_op_return_ty(*op, rhs_ty)
 394                 }
 395                 _ => Ty::Unknown,
 396             },
 397             Expr::Range { lhs, rhs, range_type } => {
 398                 let lhs_ty = lhs.map(|e| self.infer_expr_inner(e, &Expectation::none()));
 399                 let rhs_expect = lhs_ty
 400                     .as_ref()
 401                     .map_or_else(Expectation::none, |ty| Expectation::has_type(ty.clone()));
 402                 let rhs_ty = rhs.map(|e| self.infer_expr(e, &rhs_expect));
 403                 match (range_type, lhs_ty, rhs_ty) {
 404                     (RangeOp::Exclusive, None, None) => match self.resolve_range_full() {
 405                         Some(adt) => Ty::simple(TypeCtor::Adt(adt)),
 406                         None => Ty::Unknown,
 407                     },
 408                     (RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() {
 409                         Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
 410                         None => Ty::Unknown,
 411                     },
 412                     (RangeOp::Inclusive, None, Some(ty)) => {
 413                         match self.resolve_range_to_inclusive() {
 414                             Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
 415                             None => Ty::Unknown,
 416                         }
 417                     }
 418                     (RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() {
 419                         Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
 420                         None => Ty::Unknown,
 421                     },
 422                     (RangeOp::Inclusive, Some(_), Some(ty)) => {
 423                         match self.resolve_range_inclusive() {
 424                             Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
 425                             None => Ty::Unknown,
 426                         }
 427                     }
 428                     (RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() {
 429                         Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
 430                         None => Ty::Unknown,
 431                     },
 432                     (RangeOp::Inclusive, _, None) => Ty::Unknown,
 433                 }
 434             }
 435             Expr::Index { base, index } => {
 436                 let base_ty = self.infer_expr_inner(*base, &Expectation::none());
 437                 let index_ty = self.infer_expr(*index, &Expectation::none());
 438
 439                 self.resolve_associated_type_with_params(
 440                     base_ty,
 441                     self.resolve_ops_index_output(),
 442                     &[index_ty],
 443                 )
 444             }
 445             Expr::Tuple { exprs } => {
 446                 let mut tys = match &expected.ty {
 447                     ty_app!(TypeCtor::Tuple { .. }, st) => st
 448                         .iter()
 449                         .cloned()
 450                         .chain(repeat_with(|| self.table.new_type_var()))
 451                         .take(exprs.len())
 452                         .collect::<Vec<_>>(),
 453                     _ => (0..exprs.len()).map(|_| self.table.new_type_var()).collect(),
 454                 };
 455
 456                 for (expr, ty) in exprs.iter().zip(tys.iter_mut()) {
 457                     self.infer_expr_coerce(*expr, &Expectation::has_type(ty.clone()));
 458                 }
 459
 460                 Ty::apply(TypeCtor::Tuple { cardinality: tys.len() as u16 }, Substs(tys.into()))
 461             }
 462             Expr::Array(array) => {
 463                 let elem_ty = match &expected.ty {
 464                     ty_app!(TypeCtor::Array, st) | ty_app!(TypeCtor::Slice, st) => {
 465                         st.as_single().clone()
 466                     }
 467                     _ => self.table.new_type_var(),
 468                 };
 469
 470                 match array {
 471                     Array::ElementList(items) => {
 472                         for expr in items.iter() {
 473                             self.infer_expr_coerce(*expr, &Expectation::has_type(elem_ty.clone()));
 474                         }
 475                     }
 476                     Array::Repeat { initializer, repeat } => {
 477                         self.infer_expr_coerce(
 478                             *initializer,
 479                             &Expectation::has_type(elem_ty.clone()),
 480                         );
 481                         self.infer_expr(
 482                             *repeat,
 483                             &Expectation::has_type(Ty::simple(TypeCtor::Int(Uncertain::Known(
 484                                 IntTy::usize(),
 485                             )))),
 486                         );
 487                     }
 488                 }
 489
 490                 Ty::apply_one(TypeCtor::Array, elem_ty)
 491             }
 492             Expr::Literal(lit) => match lit {
 493                 Literal::Bool(..) => Ty::simple(TypeCtor::Bool),
 494                 Literal::String(..) => {
 495                     Ty::apply_one(TypeCtor::Ref(Mutability::Shared), Ty::simple(TypeCtor::Str))
 496                 }
 497                 Literal::ByteString(..) => {
 498                     let byte_type = Ty::simple(TypeCtor::Int(Uncertain::Known(IntTy::u8())));
 499                     let slice_type = Ty::apply_one(TypeCtor::Slice, byte_type);
 500                     Ty::apply_one(TypeCtor::Ref(Mutability::Shared), slice_type)
 501                 }
 502                 Literal::Char(..) => Ty::simple(TypeCtor::Char),
 503                 Literal::Int(_v, ty) => Ty::simple(TypeCtor::Int((*ty).into())),
 504                 Literal::Float(_v, ty) => Ty::simple(TypeCtor::Float((*ty).into())),
 505             },
 506         };
 507         // use a new type variable if we got Ty::Unknown here
 508         let ty = self.insert_type_vars_shallow(ty);
 509         let ty = self.resolve_ty_as_possible(ty);
 510         self.write_expr_ty(tgt_expr, ty.clone());
 511         ty
 512     }
 513
 514     fn infer_block(
 515         &mut self,
 516         statements: &[Statement],
 517         tail: Option<ExprId>,
 518         expected: &Expectation,
 519     ) -> Ty {
 520         let mut diverges = false;
 521         for stmt in statements {
 522             match stmt {
 523                 Statement::Let { pat, type_ref, initializer } => {
 524                     let decl_ty =
 525                         type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(Ty::Unknown);
 526
 527                     // Always use the declared type when specified
 528                     let mut ty = decl_ty.clone();
 529
 530                     if let Some(expr) = initializer {
 531                         let actual_ty =
 532                             self.infer_expr_coerce(*expr, &Expectation::has_type(decl_ty.clone()));
 533                         if decl_ty == Ty::Unknown {
 534                             ty = actual_ty;
 535                         }
 536                     }
 537
 538                     let ty = self.resolve_ty_as_possible(ty);
 539                     self.infer_pat(*pat, &ty, BindingMode::default());
 540                 }
 541                 Statement::Expr(expr) => {
 542                     if let ty_app!(TypeCtor::Never) = self.infer_expr(*expr, &Expectation::none()) {
 543                         diverges = true;
 544                     }
 545                 }
 546             }
 547         }
 548
 549         let ty = if let Some(expr) = tail {
 550             self.infer_expr_coerce(expr, expected)
 551         } else {
 552             self.coerce(&Ty::unit(), &expected.ty);
 553             Ty::unit()
 554         };
 555         if diverges {
 556             Ty::simple(TypeCtor::Never)
 557         } else {
 558             ty
 559         }
 560     }
 561
 562     fn infer_method_call(
 563         &mut self,
 564         tgt_expr: ExprId,
 565         receiver: ExprId,
 566         args: &[ExprId],
 567         method_name: &Name,
 568         generic_args: Option<&GenericArgs>,
 569     ) -> Ty {
 570         let receiver_ty = self.infer_expr(receiver, &Expectation::none());
 571         let canonicalized_receiver = self.canonicalizer().canonicalize_ty(receiver_ty.clone());
 572         let resolved = method_resolution::lookup_method(
 573             &canonicalized_receiver.value,
 574             self.db,
 575             method_name,
 576             &self.resolver,
 577         );
 578         let (derefed_receiver_ty, method_ty, def_generics) = match resolved {
 579             Some((ty, func)) => {
 580                 let ty = canonicalized_receiver.decanonicalize_ty(ty);
 581                 self.write_method_resolution(tgt_expr, func);
 582                 (ty, self.db.value_ty(func.into()), Some(generics(self.db, func.into())))
 583             }
 584             None => (receiver_ty, Ty::Unknown, None),
 585         };
 586         let substs = self.substs_for_method_call(def_generics, generic_args, &derefed_receiver_ty);
 587         let method_ty = method_ty.apply_substs(substs);
 588         let method_ty = self.insert_type_vars(method_ty);
 589         self.register_obligations_for_call(&method_ty);
 590         let (expected_receiver_ty, param_tys, ret_ty) = match method_ty.callable_sig(self.db) {
 591             Some(sig) => {
 592                 if !sig.params().is_empty() {
 593                     (sig.params()[0].clone(), sig.params()[1..].to_vec(), sig.ret().clone())
 594                 } else {
 595                     (Ty::Unknown, Vec::new(), sig.ret().clone())
 596                 }
 597             }
 598             None => (Ty::Unknown, Vec::new(), Ty::Unknown),
 599         };
 600         // Apply autoref so the below unification works correctly
 601         // FIXME: return correct autorefs from lookup_method
 602         let actual_receiver_ty = match expected_receiver_ty.as_reference() {
 603             Some((_, mutability)) => Ty::apply_one(TypeCtor::Ref(mutability), derefed_receiver_ty),
 604             _ => derefed_receiver_ty,
 605         };
 606         self.unify(&expected_receiver_ty, &actual_receiver_ty);
 607
 608         self.check_call_arguments(args, &param_tys);
 609         let ret_ty = self.normalize_associated_types_in(ret_ty);
 610         ret_ty
 611     }
 612
 613     fn check_call_arguments(&mut self, args: &[ExprId], param_tys: &[Ty]) {
 614         // Quoting https://github.com/rust-lang/rust/blob/6ef275e6c3cb1384ec78128eceeb4963ff788dca/src/librustc_typeck/check/mod.rs#L3325 --
 615         // We do this in a pretty awful way: first we type-check any arguments
 616         // that are not closures, then we type-check the closures. This is so
 617         // that we have more information about the types of arguments when we
 618         // type-check the functions. This isn't really the right way to do this.
 619         for &check_closures in &[false, true] {
 620             let param_iter = param_tys.iter().cloned().chain(repeat(Ty::Unknown));
 621             for (&arg, param_ty) in args.iter().zip(param_iter) {
 622                 let is_closure = match &self.body[arg] {
 623                     Expr::Lambda { .. } => true,
 624                     _ => false,
 625                 };
 626
 627                 if is_closure != check_closures {
 628                     continue;
 629                 }
 630
 631                 let param_ty = self.insert_vars_for_impl_trait(param_ty);
 632                 let param_ty = self.normalize_associated_types_in(param_ty);
 633                 self.infer_expr_coerce(arg, &Expectation::has_type(param_ty.clone()));
 634             }
 635         }
 636     }
 637
 638     fn substs_for_method_call(
 639         &mut self,
 640         def_generics: Option<Generics>,
 641         generic_args: Option<&GenericArgs>,
 642         receiver_ty: &Ty,
 643     ) -> Substs {
 644         let (total_len, _parent_len, child_len) =
 645             def_generics.as_ref().map_or((0, 0, 0), |g| g.len_split());
 646         let mut substs = Vec::with_capacity(total_len);
 647         // Parent arguments are unknown, except for the receiver type
 648         if let Some(parent_generics) = def_generics.as_ref().map(|p| p.iter_parent()) {
 649             for (_id, param) in parent_generics {
 650                 if param.name == name![Self] {
 651                     substs.push(receiver_ty.clone());
 652                 } else {
 653                     substs.push(Ty::Unknown);
 654                 }
 655             }
 656         }
 657         // handle provided type arguments
 658         if let Some(generic_args) = generic_args {
 659             // if args are provided, it should be all of them, but we can't rely on that
 660             for arg in generic_args.args.iter().take(child_len) {
 661                 match arg {
 662                     GenericArg::Type(type_ref) => {
 663                         let ty = self.make_ty(type_ref);
 664                         substs.push(ty);
 665                     }
 666                 }
 667             }
 668         };
 669         let supplied_params = substs.len();
 670         for _ in supplied_params..total_len {
 671             substs.push(Ty::Unknown);
 672         }
 673         assert_eq!(substs.len(), total_len);
 674         Substs(substs.into())
 675     }
 676
 677     fn register_obligations_for_call(&mut self, callable_ty: &Ty) {
 678         if let Ty::Apply(a_ty) = callable_ty {
 679             if let TypeCtor::FnDef(def) = a_ty.ctor {
 680                 let generic_predicates = self.db.generic_predicates(def.into());
 681                 for predicate in generic_predicates.iter() {
 682                     let predicate = predicate.clone().subst(&a_ty.parameters);
 683                     if let Some(obligation) = Obligation::from_predicate(predicate) {
 684                         self.obligations.push(obligation);
 685                     }
 686                 }
 687                 // add obligation for trait implementation, if this is a trait method
 688                 match def {
 689                     CallableDef::FunctionId(f) => {
 690                         if let AssocContainerId::TraitId(trait_) = f.lookup(self.db).container {
 691                             // construct a TraitDef
 692                             let substs =
 693                                 a_ty.parameters.prefix(generics(self.db, trait_.into()).len());
 694                             self.obligations.push(Obligation::Trait(TraitRef {
 695                                 trait_: trait_.into(),
 696                                 substs,
 697                             }));
 698                         }
 699                     }
 700                     CallableDef::StructId(_) | CallableDef::EnumVariantId(_) => {}
 701                 }
 702             }
 703         }
 704     }
 705 }