compiler/rustc_typeck/src/check/expr.rs

   1 //! Type checking expressions.
   2 //!
   3 //! See `mod.rs` for more context on type checking in general.
   4
   5 use crate::astconv::AstConv as _;
   6 use crate::check::cast;
   7 use crate::check::coercion::CoerceMany;
   8 use crate::check::fatally_break_rust;
   9 use crate::check::method::SelfSource;
  10 use crate::check::report_unexpected_variant_res;
  11 use crate::check::BreakableCtxt;
  12 use crate::check::Diverges;
  13 use crate::check::DynamicCoerceMany;
  14 use crate::check::Expectation::{self, ExpectCastableToType, ExpectHasType, NoExpectation};
  15 use crate::check::FnCtxt;
  16 use crate::check::Needs;
  17 use crate::check::TupleArgumentsFlag::DontTupleArguments;
  18 use crate::errors::{
  19     FieldMultiplySpecifiedInInitializer, FunctionalRecordUpdateOnNonStruct,
  20     YieldExprOutsideOfGenerator,
  21 };
  22 use crate::type_error_struct;
  23
  24 use crate::errors::{AddressOfTemporaryTaken, ReturnStmtOutsideOfFnBody, StructExprNonExhaustive};
  25 use rustc_ast as ast;
  26 use rustc_data_structures::fx::FxHashMap;
  27 use rustc_data_structures::stack::ensure_sufficient_stack;
  28 use rustc_errors::ErrorReported;
  29 use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder, DiagnosticId};
  30 use rustc_hir as hir;
  31 use rustc_hir::def::{CtorKind, DefKind, Res};
  32 use rustc_hir::def_id::DefId;
  33 use rustc_hir::{ExprKind, QPath};
  34 use rustc_infer::infer;
  35 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
  36 use rustc_middle::ty;
  37 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase};
  38 use rustc_middle::ty::subst::SubstsRef;
  39 use rustc_middle::ty::Ty;
  40 use rustc_middle::ty::TypeFoldable;
  41 use rustc_middle::ty::{AdtKind, Visibility};
  42 use rustc_span::edition::LATEST_STABLE_EDITION;
  43 use rustc_span::hygiene::DesugaringKind;
  44 use rustc_span::lev_distance::find_best_match_for_name;
  45 use rustc_span::source_map::Span;
  46 use rustc_span::symbol::{kw, sym, Ident, Symbol};
  47 use rustc_trait_selection::traits::{self, ObligationCauseCode};
  48
  49 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  50     fn check_expr_eq_type(&self, expr: &'tcx hir::Expr<'tcx>, expected: Ty<'tcx>) {
  51         let ty = self.check_expr_with_hint(expr, expected);
  52         self.demand_eqtype(expr.span, expected, ty);
  53     }
  54
  55     pub fn check_expr_has_type_or_error(
  56         &self,
  57         expr: &'tcx hir::Expr<'tcx>,
  58         expected: Ty<'tcx>,
  59         extend_err: impl Fn(&mut DiagnosticBuilder<'_>),
  60     ) -> Ty<'tcx> {
  61         self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected), extend_err)
  62     }
  63
  64     fn check_expr_meets_expectation_or_error(
  65         &self,
  66         expr: &'tcx hir::Expr<'tcx>,
  67         expected: Expectation<'tcx>,
  68         extend_err: impl Fn(&mut DiagnosticBuilder<'_>),
  69     ) -> Ty<'tcx> {
  70         let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
  71         let mut ty = self.check_expr_with_expectation(expr, expected);
  72
  73         // While we don't allow *arbitrary* coercions here, we *do* allow
  74         // coercions from ! to `expected`.
  75         if ty.is_never() {
  76             assert!(
  77                 !self.typeck_results.borrow().adjustments().contains_key(expr.hir_id),
  78                 "expression with never type wound up being adjusted"
  79             );
  80             let adj_ty = self.next_diverging_ty_var(TypeVariableOrigin {
  81                 kind: TypeVariableOriginKind::AdjustmentType,
  82                 span: expr.span,
  83             });
  84             self.apply_adjustments(
  85                 expr,
  86                 vec![Adjustment { kind: Adjust::NeverToAny, target: adj_ty }],
  87             );
  88             ty = adj_ty;
  89         }
  90
  91         if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
  92             let expr = expr.peel_drop_temps();
  93             self.suggest_deref_ref_or_into(&mut err, expr, expected_ty, ty, None);
  94             extend_err(&mut err);
  95             // Error possibly reported in `check_assign` so avoid emitting error again.
  96             err.emit_unless(self.is_assign_to_bool(expr, expected_ty));
  97         }
  98         ty
  99     }
 100
 101     pub(super) fn check_expr_coercable_to_type(
 102         &self,
 103         expr: &'tcx hir::Expr<'tcx>,
 104         expected: Ty<'tcx>,
 105         expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
 106     ) -> Ty<'tcx> {
 107         let ty = self.check_expr_with_hint(expr, expected);
 108         // checks don't need two phase
 109         self.demand_coerce(expr, ty, expected, expected_ty_expr, AllowTwoPhase::No)
 110     }
 111
 112     pub(super) fn check_expr_with_hint(
 113         &self,
 114         expr: &'tcx hir::Expr<'tcx>,
 115         expected: Ty<'tcx>,
 116     ) -> Ty<'tcx> {
 117         self.check_expr_with_expectation(expr, ExpectHasType(expected))
 118     }
 119
 120     fn check_expr_with_expectation_and_needs(
 121         &self,
 122         expr: &'tcx hir::Expr<'tcx>,
 123         expected: Expectation<'tcx>,
 124         needs: Needs,
 125     ) -> Ty<'tcx> {
 126         let ty = self.check_expr_with_expectation(expr, expected);
 127
 128         // If the expression is used in a place whether mutable place is required
 129         // e.g. LHS of assignment, perform the conversion.
 130         if let Needs::MutPlace = needs {
 131             self.convert_place_derefs_to_mutable(expr);
 132         }
 133
 134         ty
 135     }
 136
 137     pub(super) fn check_expr(&self, expr: &'tcx hir::Expr<'tcx>) -> Ty<'tcx> {
 138         self.check_expr_with_expectation(expr, NoExpectation)
 139     }
 140
 141     pub(super) fn check_expr_with_needs(
 142         &self,
 143         expr: &'tcx hir::Expr<'tcx>,
 144         needs: Needs,
 145     ) -> Ty<'tcx> {
 146         self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
 147     }
 148
 149     /// Invariant:
 150     /// If an expression has any sub-expressions that result in a type error,
 151     /// inspecting that expression's type with `ty.references_error()` will return
 152     /// true. Likewise, if an expression is known to diverge, inspecting its
 153     /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
 154     /// strict, _|_ can appear in the type of an expression that does not,
 155     /// itself, diverge: for example, fn() -> _|_.)
 156     /// Note that inspecting a type's structure *directly* may expose the fact
 157     /// that there are actually multiple representations for `Error`, so avoid
 158     /// that when err needs to be handled differently.
 159     pub(super) fn check_expr_with_expectation(
 160         &self,
 161         expr: &'tcx hir::Expr<'tcx>,
 162         expected: Expectation<'tcx>,
 163     ) -> Ty<'tcx> {
 164         debug!(">> type-checking: expected={:?}, expr={:?} ", expected, expr);
 165
 166         // True if `expr` is a `Try::from_ok(())` that is a result of desugaring a try block
 167         // without the final expr (e.g. `try { return; }`). We don't want to generate an
 168         // unreachable_code lint for it since warnings for autogenerated code are confusing.
 169         let is_try_block_generated_unit_expr = match expr.kind {
 170             ExprKind::Call(_, args) if expr.span.is_desugaring(DesugaringKind::TryBlock) => {
 171                 args.len() == 1 && args[0].span.is_desugaring(DesugaringKind::TryBlock)
 172             }
 173
 174             _ => false,
 175         };
 176
 177         // Warn for expressions after diverging siblings.
 178         if !is_try_block_generated_unit_expr {
 179             self.warn_if_unreachable(expr.hir_id, expr.span, "expression");
 180         }
 181
 182         // Hide the outer diverging and has_errors flags.
 183         let old_diverges = self.diverges.replace(Diverges::Maybe);
 184         let old_has_errors = self.has_errors.replace(false);
 185
 186         let ty = ensure_sufficient_stack(|| self.check_expr_kind(expr, expected));
 187
 188         // Warn for non-block expressions with diverging children.
 189         match expr.kind {
 190             ExprKind::Block(..) | ExprKind::If(..) | ExprKind::Loop(..) | ExprKind::Match(..) => {}
 191             // If `expr` is a result of desugaring the try block and is an ok-wrapped
 192             // diverging expression (e.g. it arose from desugaring of `try { return }`),
 193             // we skip issuing a warning because it is autogenerated code.
 194             ExprKind::Call(..) if expr.span.is_desugaring(DesugaringKind::TryBlock) => {}
 195             ExprKind::Call(callee, _) => self.warn_if_unreachable(expr.hir_id, callee.span, "call"),
 196             ExprKind::MethodCall(_, ref span, _, _) => {
 197                 self.warn_if_unreachable(expr.hir_id, *span, "call")
 198             }
 199             _ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression"),
 200         }
 201
 202         // Any expression that produces a value of type `!` must have diverged
 203         if ty.is_never() {
 204             self.diverges.set(self.diverges.get() | Diverges::always(expr.span));
 205         }
 206
 207         // Record the type, which applies it effects.
 208         // We need to do this after the warning above, so that
 209         // we don't warn for the diverging expression itself.
 210         self.write_ty(expr.hir_id, ty);
 211
 212         // Combine the diverging and has_error flags.
 213         self.diverges.set(self.diverges.get() | old_diverges);
 214         self.has_errors.set(self.has_errors.get() | old_has_errors);
 215
 216         debug!("type of {} is...", self.tcx.hir().node_to_string(expr.hir_id));
 217         debug!("... {:?}, expected is {:?}", ty, expected);
 218
 219         ty
 220     }
 221
 222     fn check_expr_kind(
 223         &self,
 224         expr: &'tcx hir::Expr<'tcx>,
 225         expected: Expectation<'tcx>,
 226     ) -> Ty<'tcx> {
 227         debug!("check_expr_kind(expected={:?}, expr={:?})", expected, expr);
 228
 229         let tcx = self.tcx;
 230         match expr.kind {
 231             ExprKind::Box(subexpr) => self.check_expr_box(subexpr, expected),
 232             ExprKind::Lit(ref lit) => self.check_lit(&lit, expected),
 233             ExprKind::Binary(op, lhs, rhs) => self.check_binop(expr, op, lhs, rhs),
 234             ExprKind::Assign(lhs, rhs, ref span) => {
 235                 self.check_expr_assign(expr, expected, lhs, rhs, span)
 236             }
 237             ExprKind::AssignOp(op, lhs, rhs) => self.check_binop_assign(expr, op, lhs, rhs),
 238             ExprKind::Unary(unop, oprnd) => self.check_expr_unary(unop, oprnd, expected, expr),
 239             ExprKind::AddrOf(kind, mutbl, oprnd) => {
 240                 self.check_expr_addr_of(kind, mutbl, oprnd, expected, expr)
 241             }
 242             ExprKind::Path(QPath::LangItem(lang_item, _)) => {
 243                 self.check_lang_item_path(lang_item, expr)
 244             }
 245             ExprKind::Path(ref qpath) => self.check_expr_path(qpath, expr),
 246             ExprKind::InlineAsm(asm) => self.check_expr_asm(asm),
 247             ExprKind::LlvmInlineAsm(asm) => {
 248                 for expr in asm.outputs_exprs.iter().chain(asm.inputs_exprs.iter()) {
 249                     self.check_expr(expr);
 250                 }
 251                 tcx.mk_unit()
 252             }
 253             ExprKind::Break(destination, ref expr_opt) => {
 254                 self.check_expr_break(destination, expr_opt.as_deref(), expr)
 255             }
 256             ExprKind::Continue(destination) => {
 257                 if destination.target_id.is_ok() {
 258                     tcx.types.never
 259                 } else {
 260                     // There was an error; make type-check fail.
 261                     tcx.ty_error()
 262                 }
 263             }
 264             ExprKind::Ret(ref expr_opt) => self.check_expr_return(expr_opt.as_deref(), expr),
 265             ExprKind::Loop(body, _, source, _) => {
 266                 self.check_expr_loop(body, source, expected, expr)
 267             }
 268             ExprKind::Match(discrim, arms, match_src) => {
 269                 self.check_match(expr, &discrim, arms, expected, match_src)
 270             }
 271             ExprKind::Closure(capture, decl, body_id, _, gen) => {
 272                 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
 273             }
 274             ExprKind::Block(body, _) => self.check_block_with_expected(&body, expected),
 275             ExprKind::Call(callee, args) => self.check_call(expr, &callee, args, expected),
 276             ExprKind::MethodCall(segment, span, args, _) => {
 277                 self.check_method_call(expr, segment, span, args, expected)
 278             }
 279             ExprKind::Cast(e, t) => self.check_expr_cast(e, t, expr),
 280             ExprKind::Type(e, t) => {
 281                 let ty = self.to_ty_saving_user_provided_ty(&t);
 282                 self.check_expr_eq_type(&e, ty);
 283                 ty
 284             }
 285             ExprKind::If(cond, then_expr, opt_else_expr) => {
 286                 self.check_then_else(cond, then_expr, opt_else_expr, expr.span, expected)
 287             }
 288             ExprKind::DropTemps(e) => self.check_expr_with_expectation(e, expected),
 289             ExprKind::Array(args) => self.check_expr_array(args, expected, expr),
 290             ExprKind::ConstBlock(ref anon_const) => self.to_const(anon_const).ty,
 291             ExprKind::Repeat(element, ref count) => {
 292                 self.check_expr_repeat(element, count, expected, expr)
 293             }
 294             ExprKind::Tup(elts) => self.check_expr_tuple(elts, expected, expr),
 295             ExprKind::Struct(qpath, fields, ref base_expr) => {
 296                 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
 297             }
 298             ExprKind::Field(base, field) => self.check_field(expr, &base, field),
 299             ExprKind::Index(base, idx) => self.check_expr_index(base, idx, expr),
 300             ExprKind::Yield(value, ref src) => self.check_expr_yield(value, expr, src),
 301             hir::ExprKind::Err => tcx.ty_error(),
 302         }
 303     }
 304
 305     fn check_expr_box(&self, expr: &'tcx hir::Expr<'tcx>, expected: Expectation<'tcx>) -> Ty<'tcx> {
 306         let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| match ty.kind() {
 307             ty::Adt(def, _) if def.is_box() => Expectation::rvalue_hint(self, ty.boxed_ty()),
 308             _ => NoExpectation,
 309         });
 310         let referent_ty = self.check_expr_with_expectation(expr, expected_inner);
 311         self.tcx.mk_box(referent_ty)
 312     }
 313
 314     fn check_expr_unary(
 315         &self,
 316         unop: hir::UnOp,
 317         oprnd: &'tcx hir::Expr<'tcx>,
 318         expected: Expectation<'tcx>,
 319         expr: &'tcx hir::Expr<'tcx>,
 320     ) -> Ty<'tcx> {
 321         let tcx = self.tcx;
 322         let expected_inner = match unop {
 323             hir::UnOp::Not | hir::UnOp::Neg => expected,
 324             hir::UnOp::Deref => NoExpectation,
 325         };
 326         let mut oprnd_t = self.check_expr_with_expectation(&oprnd, expected_inner);
 327
 328         if !oprnd_t.references_error() {
 329             oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
 330             match unop {
 331                 hir::UnOp::Deref => {
 332                     if let Some(ty) = self.lookup_derefing(expr, oprnd, oprnd_t) {
 333                         oprnd_t = ty;
 334                     } else {
 335                         let mut err = type_error_struct!(
 336                             tcx.sess,
 337                             expr.span,
 338                             oprnd_t,
 339                             E0614,
 340                             "type `{}` cannot be dereferenced",
 341                             oprnd_t,
 342                         );
 343                         let sp = tcx.sess.source_map().start_point(expr.span);
 344                         if let Some(sp) =
 345                             tcx.sess.parse_sess.ambiguous_block_expr_parse.borrow().get(&sp)
 346                         {
 347                             tcx.sess.parse_sess.expr_parentheses_needed(&mut err, *sp);
 348                         }
 349                         err.emit();
 350                         oprnd_t = tcx.ty_error();
 351                     }
 352                 }
 353                 hir::UnOp::Not => {
 354                     let result = self.check_user_unop(expr, oprnd_t, unop);
 355                     // If it's builtin, we can reuse the type, this helps inference.
 356                     if !(oprnd_t.is_integral() || *oprnd_t.kind() == ty::Bool) {
 357                         oprnd_t = result;
 358                     }
 359                 }
 360                 hir::UnOp::Neg => {
 361                     let result = self.check_user_unop(expr, oprnd_t, unop);
 362                     // If it's builtin, we can reuse the type, this helps inference.
 363                     if !oprnd_t.is_numeric() {
 364                         oprnd_t = result;
 365                     }
 366                 }
 367             }
 368         }
 369         oprnd_t
 370     }
 371
 372     fn check_expr_addr_of(
 373         &self,
 374         kind: hir::BorrowKind,
 375         mutbl: hir::Mutability,
 376         oprnd: &'tcx hir::Expr<'tcx>,
 377         expected: Expectation<'tcx>,
 378         expr: &'tcx hir::Expr<'tcx>,
 379     ) -> Ty<'tcx> {
 380         let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
 381             match ty.kind() {
 382                 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
 383                     if oprnd.is_syntactic_place_expr() {
 384                         // Places may legitimately have unsized types.
 385                         // For example, dereferences of a fat pointer and
 386                         // the last field of a struct can be unsized.
 387                         ExpectHasType(ty)
 388                     } else {
 389                         Expectation::rvalue_hint(self, ty)
 390                     }
 391                 }
 392                 _ => NoExpectation,
 393             }
 394         });
 395         let ty =
 396             self.check_expr_with_expectation_and_needs(&oprnd, hint, Needs::maybe_mut_place(mutbl));
 397
 398         let tm = ty::TypeAndMut { ty, mutbl };
 399         match kind {
 400             _ if tm.ty.references_error() => self.tcx.ty_error(),
 401             hir::BorrowKind::Raw => {
 402                 self.check_named_place_expr(oprnd);
 403                 self.tcx.mk_ptr(tm)
 404             }
 405             hir::BorrowKind::Ref => {
 406                 // Note: at this point, we cannot say what the best lifetime
 407                 // is to use for resulting pointer.  We want to use the
 408                 // shortest lifetime possible so as to avoid spurious borrowck
 409                 // errors.  Moreover, the longest lifetime will depend on the
 410                 // precise details of the value whose address is being taken
 411                 // (and how long it is valid), which we don't know yet until
 412                 // type inference is complete.
 413                 //
 414                 // Therefore, here we simply generate a region variable. The
 415                 // region inferencer will then select a suitable value.
 416                 // Finally, borrowck will infer the value of the region again,
 417                 // this time with enough precision to check that the value
 418                 // whose address was taken can actually be made to live as long
 419                 // as it needs to live.
 420                 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
 421                 self.tcx.mk_ref(region, tm)
 422             }
 423         }
 424     }
 425
 426     /// Does this expression refer to a place that either:
 427     /// * Is based on a local or static.
 428     /// * Contains a dereference
 429     /// Note that the adjustments for the children of `expr` should already
 430     /// have been resolved.
 431     fn check_named_place_expr(&self, oprnd: &'tcx hir::Expr<'tcx>) {
 432         let is_named = oprnd.is_place_expr(|base| {
 433             // Allow raw borrows if there are any deref adjustments.
 434             //
 435             // const VAL: (i32,) = (0,);
 436             // const REF: &(i32,) = &(0,);
 437             //
 438             // &raw const VAL.0;            // ERROR
 439             // &raw const REF.0;            // OK, same as &raw const (*REF).0;
 440             //
 441             // This is maybe too permissive, since it allows
 442             // `let u = &raw const Box::new((1,)).0`, which creates an
 443             // immediately dangling raw pointer.
 444             self.typeck_results
 445                 .borrow()
 446                 .adjustments()
 447                 .get(base.hir_id)
 448                 .map_or(false, |x| x.iter().any(|adj| matches!(adj.kind, Adjust::Deref(_))))
 449         });
 450         if !is_named {
 451             self.tcx.sess.emit_err(AddressOfTemporaryTaken { span: oprnd.span })
 452         }
 453     }
 454
 455     fn check_lang_item_path(
 456         &self,
 457         lang_item: hir::LangItem,
 458         expr: &'tcx hir::Expr<'tcx>,
 459     ) -> Ty<'tcx> {
 460         self.resolve_lang_item_path(lang_item, expr.span, expr.hir_id).1
 461     }
 462
 463     fn check_expr_path(
 464         &self,
 465         qpath: &'tcx hir::QPath<'tcx>,
 466         expr: &'tcx hir::Expr<'tcx>,
 467     ) -> Ty<'tcx> {
 468         let tcx = self.tcx;
 469         let (res, opt_ty, segs) =
 470             self.resolve_ty_and_res_fully_qualified_call(qpath, expr.hir_id, expr.span);
 471         let ty = match res {
 472             Res::Err => {
 473                 self.set_tainted_by_errors();
 474                 tcx.ty_error()
 475             }
 476             Res::Def(DefKind::Ctor(_, CtorKind::Fictive), _) => {
 477                 report_unexpected_variant_res(tcx, res, expr.span);
 478                 tcx.ty_error()
 479             }
 480             _ => self.instantiate_value_path(segs, opt_ty, res, expr.span, expr.hir_id).0,
 481         };
 482
 483         if let ty::FnDef(..) = ty.kind() {
 484             let fn_sig = ty.fn_sig(tcx);
 485             if !tcx.features().unsized_fn_params {
 486                 // We want to remove some Sized bounds from std functions,
 487                 // but don't want to expose the removal to stable Rust.
 488                 // i.e., we don't want to allow
 489                 //
 490                 // ```rust
 491                 // drop as fn(str);
 492                 // ```
 493                 //
 494                 // to work in stable even if the Sized bound on `drop` is relaxed.
 495                 for i in 0..fn_sig.inputs().skip_binder().len() {
 496                     // We just want to check sizedness, so instead of introducing
 497                     // placeholder lifetimes with probing, we just replace higher lifetimes
 498                     // with fresh vars.
 499                     let input = self
 500                         .replace_bound_vars_with_fresh_vars(
 501                             expr.span,
 502                             infer::LateBoundRegionConversionTime::FnCall,
 503                             fn_sig.input(i),
 504                         )
 505                         .0;
 506                     self.require_type_is_sized_deferred(
 507                         input,
 508                         expr.span,
 509                         traits::SizedArgumentType(None),
 510                     );
 511                 }
 512             }
 513             // Here we want to prevent struct constructors from returning unsized types.
 514             // There were two cases this happened: fn pointer coercion in stable
 515             // and usual function call in presence of unsized_locals.
 516             // Also, as we just want to check sizedness, instead of introducing
 517             // placeholder lifetimes with probing, we just replace higher lifetimes
 518             // with fresh vars.
 519             let output = self
 520                 .replace_bound_vars_with_fresh_vars(
 521                     expr.span,
 522                     infer::LateBoundRegionConversionTime::FnCall,
 523                     fn_sig.output(),
 524                 )
 525                 .0;
 526             self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
 527         }
 528
 529         // We always require that the type provided as the value for
 530         // a type parameter outlives the moment of instantiation.
 531         let substs = self.typeck_results.borrow().node_substs(expr.hir_id);
 532         self.add_wf_bounds(substs, expr);
 533
 534         ty
 535     }
 536
 537     fn check_expr_break(
 538         &self,
 539         destination: hir::Destination,
 540         expr_opt: Option<&'tcx hir::Expr<'tcx>>,
 541         expr: &'tcx hir::Expr<'tcx>,
 542     ) -> Ty<'tcx> {
 543         let tcx = self.tcx;
 544         if let Ok(target_id) = destination.target_id {
 545             let (e_ty, cause);
 546             if let Some(e) = expr_opt {
 547                 // If this is a break with a value, we need to type-check
 548                 // the expression. Get an expected type from the loop context.
 549                 let opt_coerce_to = {
 550                     // We should release `enclosing_breakables` before the `check_expr_with_hint`
 551                     // below, so can't move this block of code to the enclosing scope and share
 552                     // `ctxt` with the second `encloding_breakables` borrow below.
 553                     let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
 554                     match enclosing_breakables.opt_find_breakable(target_id) {
 555                         Some(ctxt) => ctxt.coerce.as_ref().map(|coerce| coerce.expected_ty()),
 556                         None => {
 557                             // Avoid ICE when `break` is inside a closure (#65383).
 558                             return tcx.ty_error_with_message(
 559                                 expr.span,
 560                                 "break was outside loop, but no error was emitted",
 561                             );
 562                         }
 563                     }
 564                 };
 565
 566                 // If the loop context is not a `loop { }`, then break with
 567                 // a value is illegal, and `opt_coerce_to` will be `None`.
 568                 // Just set expectation to error in that case.
 569                 let coerce_to = opt_coerce_to.unwrap_or_else(|| tcx.ty_error());
 570
 571                 // Recurse without `enclosing_breakables` borrowed.
 572                 e_ty = self.check_expr_with_hint(e, coerce_to);
 573                 cause = self.misc(e.span);
 574             } else {
 575                 // Otherwise, this is a break *without* a value. That's
 576                 // always legal, and is equivalent to `break ()`.
 577                 e_ty = tcx.mk_unit();
 578                 cause = self.misc(expr.span);
 579             }
 580
 581             // Now that we have type-checked `expr_opt`, borrow
 582             // the `enclosing_loops` field and let's coerce the
 583             // type of `expr_opt` into what is expected.
 584             let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
 585             let ctxt = match enclosing_breakables.opt_find_breakable(target_id) {
 586                 Some(ctxt) => ctxt,
 587                 None => {
 588                     // Avoid ICE when `break` is inside a closure (#65383).
 589                     return tcx.ty_error_with_message(
 590                         expr.span,
 591                         "break was outside loop, but no error was emitted",
 592                     );
 593                 }
 594             };
 595
 596             if let Some(ref mut coerce) = ctxt.coerce {
 597                 if let Some(ref e) = expr_opt {
 598                     coerce.coerce(self, &cause, e, e_ty);
 599                 } else {
 600                     assert!(e_ty.is_unit());
 601                     let ty = coerce.expected_ty();
 602                     coerce.coerce_forced_unit(
 603                         self,
 604                         &cause,
 605                         &mut |mut err| {
 606                             self.suggest_mismatched_types_on_tail(
 607                                 &mut err, expr, ty, e_ty, target_id,
 608                             );
 609                             if let Some(val) = ty_kind_suggestion(ty) {
 610                                 let label = destination
 611                                     .label
 612                                     .map(|l| format!(" {}", l.ident))
 613                                     .unwrap_or_else(String::new);
 614                                 err.span_suggestion(
 615                                     expr.span,
 616                                     "give it a value of the expected type",
 617                                     format!("break{} {}", label, val),
 618                                     Applicability::HasPlaceholders,
 619                                 );
 620                             }
 621                         },
 622                         false,
 623                     );
 624                 }
 625             } else {
 626                 // If `ctxt.coerce` is `None`, we can just ignore
 627                 // the type of the expression.  This is because
 628                 // either this was a break *without* a value, in
 629                 // which case it is always a legal type (`()`), or
 630                 // else an error would have been flagged by the
 631                 // `loops` pass for using break with an expression
 632                 // where you are not supposed to.
 633                 assert!(expr_opt.is_none() || self.tcx.sess.has_errors());
 634             }
 635
 636             // If we encountered a `break`, then (no surprise) it may be possible to break from the
 637             // loop... unless the value being returned from the loop diverges itself, e.g.
 638             // `break return 5` or `break loop {}`.
 639             ctxt.may_break |= !self.diverges.get().is_always();
 640
 641             // the type of a `break` is always `!`, since it diverges
 642             tcx.types.never
 643         } else {
 644             // Otherwise, we failed to find the enclosing loop;
 645             // this can only happen if the `break` was not
 646             // inside a loop at all, which is caught by the
 647             // loop-checking pass.
 648             let err = self.tcx.ty_error_with_message(
 649                 expr.span,
 650                 "break was outside loop, but no error was emitted",
 651             );
 652
 653             // We still need to assign a type to the inner expression to
 654             // prevent the ICE in #43162.
 655             if let Some(e) = expr_opt {
 656                 self.check_expr_with_hint(e, err);
 657
 658                 // ... except when we try to 'break rust;'.
 659                 // ICE this expression in particular (see #43162).
 660                 if let ExprKind::Path(QPath::Resolved(_, path)) = e.kind {
 661                     if path.segments.len() == 1 && path.segments[0].ident.name == sym::rust {
 662                         fatally_break_rust(self.tcx.sess);
 663                     }
 664                 }
 665             }
 666
 667             // There was an error; make type-check fail.
 668             err
 669         }
 670     }
 671
 672     fn check_expr_return(
 673         &self,
 674         expr_opt: Option<&'tcx hir::Expr<'tcx>>,
 675         expr: &'tcx hir::Expr<'tcx>,
 676     ) -> Ty<'tcx> {
 677         if self.ret_coercion.is_none() {
 678             let mut err = ReturnStmtOutsideOfFnBody {
 679                 span: expr.span,
 680                 encl_body_span: None,
 681                 encl_fn_span: None,
 682             };
 683
 684             let encl_item_id = self.tcx.hir().get_parent_item(expr.hir_id);
 685
 686             if let Some(hir::Node::Item(hir::Item {
 687                 kind: hir::ItemKind::Fn(..),
 688                 span: encl_fn_span,
 689                 ..
 690             }))
 691             | Some(hir::Node::TraitItem(hir::TraitItem {
 692                 kind: hir::TraitItemKind::Fn(_, hir::TraitFn::Provided(_)),
 693                 span: encl_fn_span,
 694                 ..
 695             }))
 696             | Some(hir::Node::ImplItem(hir::ImplItem {
 697                 kind: hir::ImplItemKind::Fn(..),
 698                 span: encl_fn_span,
 699                 ..
 700             })) = self.tcx.hir().find(encl_item_id)
 701             {
 702                 // We are inside a function body, so reporting "return statement
 703                 // outside of function body" needs an explanation.
 704
 705                 let encl_body_owner_id = self.tcx.hir().enclosing_body_owner(expr.hir_id);
 706
 707                 // If this didn't hold, we would not have to report an error in
 708                 // the first place.
 709                 assert_ne!(encl_item_id, encl_body_owner_id);
 710
 711                 let encl_body_id = self.tcx.hir().body_owned_by(encl_body_owner_id);
 712                 let encl_body = self.tcx.hir().body(encl_body_id);
 713
 714                 err.encl_body_span = Some(encl_body.value.span);
 715                 err.encl_fn_span = Some(*encl_fn_span);
 716             }
 717
 718             self.tcx.sess.emit_err(err);
 719
 720             if let Some(e) = expr_opt {
 721                 // We still have to type-check `e` (issue #86188), but calling
 722                 // `check_return_expr` only works inside fn bodies.
 723                 self.check_expr(e);
 724             }
 725         } else if let Some(e) = expr_opt {
 726             if self.ret_coercion_span.get().is_none() {
 727                 self.ret_coercion_span.set(Some(e.span));
 728             }
 729             self.check_return_expr(e);
 730         } else {
 731             let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
 732             if self.ret_coercion_span.get().is_none() {
 733                 self.ret_coercion_span.set(Some(expr.span));
 734             }
 735             let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
 736             if let Some((fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
 737                 coercion.coerce_forced_unit(
 738                     self,
 739                     &cause,
 740                     &mut |db| {
 741                         let span = fn_decl.output.span();
 742                         if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
 743                             db.span_label(
 744                                 span,
 745                                 format!("expected `{}` because of this return type", snippet),
 746                             );
 747                         }
 748                     },
 749                     true,
 750                 );
 751             } else {
 752                 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
 753             }
 754         }
 755         self.tcx.types.never
 756     }
 757
 758     pub(super) fn check_return_expr(&self, return_expr: &'tcx hir::Expr<'tcx>) {
 759         let ret_coercion = self.ret_coercion.as_ref().unwrap_or_else(|| {
 760             span_bug!(return_expr.span, "check_return_expr called outside fn body")
 761         });
 762
 763         let ret_ty = ret_coercion.borrow().expected_ty();
 764         let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty);
 765         ret_coercion.borrow_mut().coerce(
 766             self,
 767             &self.cause(return_expr.span, ObligationCauseCode::ReturnValue(return_expr.hir_id)),
 768             return_expr,
 769             return_expr_ty,
 770         );
 771     }
 772
 773     pub(crate) fn check_lhs_assignable(
 774         &self,
 775         lhs: &'tcx hir::Expr<'tcx>,
 776         err_code: &'static str,
 777         expr_span: &Span,
 778     ) {
 779         if lhs.is_syntactic_place_expr() {
 780             return;
 781         }
 782
 783         // FIXME: Make this use SessionDiagnostic once error codes can be dynamically set.
 784         let mut err = self.tcx.sess.struct_span_err_with_code(
 785             *expr_span,
 786             "invalid left-hand side of assignment",
 787             DiagnosticId::Error(err_code.into()),
 788         );
 789         err.span_label(lhs.span, "cannot assign to this expression");
 790         err.emit();
 791     }
 792
 793     // A generic function for checking the 'then' and 'else' clauses in an 'if'
 794     // or 'if-else' expression.
 795     fn check_then_else(
 796         &self,
 797         cond_expr: &'tcx hir::Expr<'tcx>,
 798         then_expr: &'tcx hir::Expr<'tcx>,
 799         opt_else_expr: Option<&'tcx hir::Expr<'tcx>>,
 800         sp: Span,
 801         orig_expected: Expectation<'tcx>,
 802     ) -> Ty<'tcx> {
 803         let cond_ty = self.check_expr_has_type_or_error(cond_expr, self.tcx.types.bool, |_| {});
 804
 805         self.warn_if_unreachable(cond_expr.hir_id, then_expr.span, "block in `if` expression");
 806
 807         let cond_diverges = self.diverges.get();
 808         self.diverges.set(Diverges::Maybe);
 809
 810         let expected = orig_expected.adjust_for_branches(self);
 811         let then_ty = self.check_expr_with_expectation(then_expr, expected);
 812         let then_diverges = self.diverges.get();
 813         self.diverges.set(Diverges::Maybe);
 814
 815         // We've already taken the expected type's preferences
 816         // into account when typing the `then` branch. To figure
 817         // out the initial shot at a LUB, we thus only consider
 818         // `expected` if it represents a *hard* constraint
 819         // (`only_has_type`); otherwise, we just go with a
 820         // fresh type variable.
 821         let coerce_to_ty = expected.coercion_target_type(self, sp);
 822         let mut coerce: DynamicCoerceMany<'_> = CoerceMany::new(coerce_to_ty);
 823
 824         coerce.coerce(self, &self.misc(sp), then_expr, then_ty);
 825
 826         if let Some(else_expr) = opt_else_expr {
 827             let else_ty = self.check_expr_with_expectation(else_expr, expected);
 828             let else_diverges = self.diverges.get();
 829
 830             let opt_suggest_box_span =
 831                 self.opt_suggest_box_span(else_expr.span, else_ty, orig_expected);
 832             let if_cause =
 833                 self.if_cause(sp, then_expr, else_expr, then_ty, else_ty, opt_suggest_box_span);
 834
 835             coerce.coerce(self, &if_cause, else_expr, else_ty);
 836
 837             // We won't diverge unless both branches do (or the condition does).
 838             self.diverges.set(cond_diverges | then_diverges & else_diverges);
 839         } else {
 840             self.if_fallback_coercion(sp, then_expr, &mut coerce, |hir_id, span| {
 841                 self.maybe_get_coercion_reason_if(hir_id, span)
 842             });
 843
 844             // If the condition is false we can't diverge.
 845             self.diverges.set(cond_diverges);
 846         }
 847
 848         let result_ty = coerce.complete(self);
 849         if cond_ty.references_error() { self.tcx.ty_error() } else { result_ty }
 850     }
 851
 852     /// Type check assignment expression `expr` of form `lhs = rhs`.
 853     /// The expected type is `()` and is passed to the function for the purposes of diagnostics.
 854     fn check_expr_assign(
 855         &self,
 856         expr: &'tcx hir::Expr<'tcx>,
 857         expected: Expectation<'tcx>,
 858         lhs: &'tcx hir::Expr<'tcx>,
 859         rhs: &'tcx hir::Expr<'tcx>,
 860         span: &Span,
 861     ) -> Ty<'tcx> {
 862         let expected_ty = expected.coercion_target_type(self, expr.span);
 863         if expected_ty == self.tcx.types.bool {
 864             // The expected type is `bool` but this will result in `()` so we can reasonably
 865             // say that the user intended to write `lhs == rhs` instead of `lhs = rhs`.
 866             // The likely cause of this is `if foo = bar { .. }`.
 867             let actual_ty = self.tcx.mk_unit();
 868             let mut err = self.demand_suptype_diag(expr.span, expected_ty, actual_ty).unwrap();
 869             let lhs_ty = self.check_expr(&lhs);
 870             let rhs_ty = self.check_expr(&rhs);
 871             let (applicability, eq) = if self.can_coerce(rhs_ty, lhs_ty) {
 872                 (Applicability::MachineApplicable, true)
 873             } else {
 874                 (Applicability::MaybeIncorrect, false)
 875             };
 876             if !lhs.is_syntactic_place_expr() {
 877                 // Do not suggest `if let x = y` as `==` is way more likely to be the intention.
 878                 let mut span_err = || {
 879                     // Likely `if let` intended.
 880                     err.span_suggestion_verbose(
 881                         expr.span.shrink_to_lo(),
 882                         "you might have meant to use pattern matching",
 883                         "let ".to_string(),
 884                         applicability,
 885                     );
 886                 };
 887                 if let hir::Node::Expr(hir::Expr {
 888                     kind: ExprKind::Match(_, _, hir::MatchSource::WhileDesugar),
 889                     ..
 890                 }) = self.tcx.hir().get(
 891                     self.tcx.hir().get_parent_node(self.tcx.hir().get_parent_node(expr.hir_id)),
 892                 ) {
 893                     span_err();
 894                 } else if let hir::Node::Expr(hir::Expr { kind: ExprKind::If { .. }, .. }) =
 895                     self.tcx.hir().get(self.tcx.hir().get_parent_node(expr.hir_id))
 896                 {
 897                     span_err();
 898                 }
 899             }
 900             if eq {
 901                 err.span_suggestion_verbose(
 902                     *span,
 903                     "you might have meant to compare for equality",
 904                     "==".to_string(),
 905                     applicability,
 906                 );
 907             }
 908
 909             if self.sess().if_let_suggestions.borrow().get(&expr.span).is_some() {
 910                 // We already emitted an `if let` suggestion due to an identifier not found.
 911                 err.delay_as_bug();
 912             } else {
 913                 err.emit();
 914             }
 915             return self.tcx.ty_error();
 916         }
 917
 918         self.check_lhs_assignable(lhs, "E0070", span);
 919
 920         let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
 921         let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty, Some(lhs));
 922
 923         self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
 924
 925         if lhs_ty.references_error() || rhs_ty.references_error() {
 926             self.tcx.ty_error()
 927         } else {
 928             self.tcx.mk_unit()
 929         }
 930     }
 931
 932     fn check_expr_loop(
 933         &self,
 934         body: &'tcx hir::Block<'tcx>,
 935         source: hir::LoopSource,
 936         expected: Expectation<'tcx>,
 937         expr: &'tcx hir::Expr<'tcx>,
 938     ) -> Ty<'tcx> {
 939         let coerce = match source {
 940             // you can only use break with a value from a normal `loop { }`
 941             hir::LoopSource::Loop => {
 942                 let coerce_to = expected.coercion_target_type(self, body.span);
 943                 Some(CoerceMany::new(coerce_to))
 944             }
 945
 946             hir::LoopSource::While | hir::LoopSource::WhileLet | hir::LoopSource::ForLoop => None,
 947         };
 948
 949         let ctxt = BreakableCtxt {
 950             coerce,
 951             may_break: false, // Will get updated if/when we find a `break`.
 952         };
 953
 954         let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
 955             self.check_block_no_value(&body);
 956         });
 957
 958         if ctxt.may_break {
 959             // No way to know whether it's diverging because
 960             // of a `break` or an outer `break` or `return`.
 961             self.diverges.set(Diverges::Maybe);
 962         }
 963
 964         // If we permit break with a value, then result type is
 965         // the LUB of the breaks (possibly ! if none); else, it
 966         // is nil. This makes sense because infinite loops
 967         // (which would have type !) are only possible iff we
 968         // permit break with a value [1].
 969         if ctxt.coerce.is_none() && !ctxt.may_break {
 970             // [1]
 971             self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
 972         }
 973         ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
 974     }
 975
 976     /// Checks a method call.
 977     fn check_method_call(
 978         &self,
 979         expr: &'tcx hir::Expr<'tcx>,
 980         segment: &hir::PathSegment<'_>,
 981         span: Span,
 982         args: &'tcx [hir::Expr<'tcx>],
 983         expected: Expectation<'tcx>,
 984     ) -> Ty<'tcx> {
 985         let rcvr = &args[0];
 986         let rcvr_t = self.check_expr(&rcvr);
 987         // no need to check for bot/err -- callee does that
 988         let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
 989
 990         let method = match self.lookup_method(rcvr_t, segment, span, expr, rcvr, args) {
 991             Ok(method) => {
 992                 // We could add a "consider `foo::<params>`" suggestion here, but I wasn't able to
 993                 // trigger this codepath causing `structuraly_resolved_type` to emit an error.
 994
 995                 self.write_method_call(expr.hir_id, method);
 996                 Ok(method)
 997             }
 998             Err(error) => {
 999                 if segment.ident.name != kw::Empty {
1000                     if let Some(mut err) = self.report_method_error(
1001                         span,
1002                         rcvr_t,
1003                         segment.ident,
1004                         SelfSource::MethodCall(&args[0]),
1005                         error,
1006                         Some(args),
1007                     ) {
1008                         err.emit();
1009                     }
1010                 }
1011                 Err(())
1012             }
1013         };
1014
1015         // Call the generic checker.
1016         self.check_method_argument_types(
1017             span,
1018             expr,
1019             method,
1020             &args[1..],
1021             DontTupleArguments,
1022             expected,
1023         )
1024     }
1025
1026     fn check_expr_cast(
1027         &self,
1028         e: &'tcx hir::Expr<'tcx>,
1029         t: &'tcx hir::Ty<'tcx>,
1030         expr: &'tcx hir::Expr<'tcx>,
1031     ) -> Ty<'tcx> {
1032         // Find the type of `e`. Supply hints based on the type we are casting to,
1033         // if appropriate.
1034         let t_cast = self.to_ty_saving_user_provided_ty(t);
1035         let t_cast = self.resolve_vars_if_possible(t_cast);
1036         let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
1037         let t_cast = self.resolve_vars_if_possible(t_cast);
1038
1039         // Eagerly check for some obvious errors.
1040         if t_expr.references_error() || t_cast.references_error() {
1041             self.tcx.ty_error()
1042         } else {
1043             // Defer other checks until we're done type checking.
1044             let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
1045             match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
1046                 Ok(cast_check) => {
1047                     deferred_cast_checks.push(cast_check);
1048                     t_cast
1049                 }
1050                 Err(ErrorReported) => self.tcx.ty_error(),
1051             }
1052         }
1053     }
1054
1055     fn check_expr_array(
1056         &self,
1057         args: &'tcx [hir::Expr<'tcx>],
1058         expected: Expectation<'tcx>,
1059         expr: &'tcx hir::Expr<'tcx>,
1060     ) -> Ty<'tcx> {
1061         let element_ty = if !args.is_empty() {
1062             let coerce_to = expected
1063                 .to_option(self)
1064                 .and_then(|uty| match *uty.kind() {
1065                     ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
1066                     _ => None,
1067                 })
1068                 .unwrap_or_else(|| {
1069                     self.next_ty_var(TypeVariableOrigin {
1070                         kind: TypeVariableOriginKind::TypeInference,
1071                         span: expr.span,
1072                     })
1073                 });
1074             let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
1075             assert_eq!(self.diverges.get(), Diverges::Maybe);
1076             for e in args {
1077                 let e_ty = self.check_expr_with_hint(e, coerce_to);
1078                 let cause = self.misc(e.span);
1079                 coerce.coerce(self, &cause, e, e_ty);
1080             }
1081             coerce.complete(self)
1082         } else {
1083             self.next_ty_var(TypeVariableOrigin {
1084                 kind: TypeVariableOriginKind::TypeInference,
1085                 span: expr.span,
1086             })
1087         };
1088         self.tcx.mk_array(element_ty, args.len() as u64)
1089     }
1090
1091     fn check_expr_repeat(
1092         &self,
1093         element: &'tcx hir::Expr<'tcx>,
1094         count: &'tcx hir::AnonConst,
1095         expected: Expectation<'tcx>,
1096         _expr: &'tcx hir::Expr<'tcx>,
1097     ) -> Ty<'tcx> {
1098         let tcx = self.tcx;
1099         let count = self.to_const(count);
1100
1101         let uty = match expected {
1102             ExpectHasType(uty) => match *uty.kind() {
1103                 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
1104                 _ => None,
1105             },
1106             _ => None,
1107         };
1108
1109         let (element_ty, t) = match uty {
1110             Some(uty) => {
1111                 self.check_expr_coercable_to_type(&element, uty, None);
1112                 (uty, uty)
1113             }
1114             None => {
1115                 let ty = self.next_ty_var(TypeVariableOrigin {
1116                     kind: TypeVariableOriginKind::MiscVariable,
1117                     span: element.span,
1118                 });
1119                 let element_ty = self.check_expr_has_type_or_error(&element, ty, |_| {});
1120                 (element_ty, ty)
1121             }
1122         };
1123
1124         if element_ty.references_error() {
1125             return tcx.ty_error();
1126         }
1127
1128         tcx.mk_ty(ty::Array(t, count))
1129     }
1130
1131     fn check_expr_tuple(
1132         &self,
1133         elts: &'tcx [hir::Expr<'tcx>],
1134         expected: Expectation<'tcx>,
1135         expr: &'tcx hir::Expr<'tcx>,
1136     ) -> Ty<'tcx> {
1137         let flds = expected.only_has_type(self).and_then(|ty| {
1138             let ty = self.resolve_vars_with_obligations(ty);
1139             match ty.kind() {
1140                 ty::Tuple(flds) => Some(&flds[..]),
1141                 _ => None,
1142             }
1143         });
1144
1145         let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| match flds {
1146             Some(fs) if i < fs.len() => {
1147                 let ety = fs[i].expect_ty();
1148                 self.check_expr_coercable_to_type(&e, ety, None);
1149                 ety
1150             }
1151             _ => self.check_expr_with_expectation(&e, NoExpectation),
1152         });
1153         let tuple = self.tcx.mk_tup(elt_ts_iter);
1154         if tuple.references_error() {
1155             self.tcx.ty_error()
1156         } else {
1157             self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
1158             tuple
1159         }
1160     }
1161
1162     fn check_expr_struct(
1163         &self,
1164         expr: &hir::Expr<'_>,
1165         expected: Expectation<'tcx>,
1166         qpath: &QPath<'_>,
1167         fields: &'tcx [hir::ExprField<'tcx>],
1168         base_expr: &'tcx Option<&'tcx hir::Expr<'tcx>>,
1169     ) -> Ty<'tcx> {
1170         // Find the relevant variant
1171         let (variant, adt_ty) = if let Some(variant_ty) = self.check_struct_path(qpath, expr.hir_id)
1172         {
1173             variant_ty
1174         } else {
1175             self.check_struct_fields_on_error(fields, base_expr);
1176             return self.tcx.ty_error();
1177         };
1178
1179         // Prohibit struct expressions when non-exhaustive flag is set.
1180         let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
1181         if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
1182             self.tcx
1183                 .sess
1184                 .emit_err(StructExprNonExhaustive { span: expr.span, what: adt.variant_descr() });
1185         }
1186
1187         let error_happened = self.check_expr_struct_fields(
1188             adt_ty,
1189             expected,
1190             expr.hir_id,
1191             qpath.span(),
1192             variant,
1193             fields,
1194             base_expr.is_none(),
1195         );
1196         if let Some(base_expr) = base_expr {
1197             // If check_expr_struct_fields hit an error, do not attempt to populate
1198             // the fields with the base_expr. This could cause us to hit errors later
1199             // when certain fields are assumed to exist that in fact do not.
1200             if !error_happened {
1201                 self.check_expr_has_type_or_error(base_expr, adt_ty, |_| {});
1202                 match adt_ty.kind() {
1203                     ty::Adt(adt, substs) if adt.is_struct() => {
1204                         let fru_field_types = adt
1205                             .non_enum_variant()
1206                             .fields
1207                             .iter()
1208                             .map(|f| {
1209                                 self.normalize_associated_types_in(
1210                                     expr.span,
1211                                     f.ty(self.tcx, substs),
1212                                 )
1213                             })
1214                             .collect();
1215
1216                         self.typeck_results
1217                             .borrow_mut()
1218                             .fru_field_types_mut()
1219                             .insert(expr.hir_id, fru_field_types);
1220                     }
1221                     _ => {
1222                         self.tcx
1223                             .sess
1224                             .emit_err(FunctionalRecordUpdateOnNonStruct { span: base_expr.span });
1225                     }
1226                 }
1227             }
1228         }
1229         self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
1230         adt_ty
1231     }
1232
1233     fn check_expr_struct_fields(
1234         &self,
1235         adt_ty: Ty<'tcx>,
1236         expected: Expectation<'tcx>,
1237         expr_id: hir::HirId,
1238         span: Span,
1239         variant: &'tcx ty::VariantDef,
1240         ast_fields: &'tcx [hir::ExprField<'tcx>],
1241         check_completeness: bool,
1242     ) -> bool {
1243         let tcx = self.tcx;
1244
1245         let adt_ty_hint = self
1246             .expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
1247             .get(0)
1248             .cloned()
1249             .unwrap_or(adt_ty);
1250         // re-link the regions that EIfEO can erase.
1251         self.demand_eqtype(span, adt_ty_hint, adt_ty);
1252
1253         let (substs, adt_kind, kind_name) = match adt_ty.kind() {
1254             ty::Adt(adt, substs) => (substs, adt.adt_kind(), adt.variant_descr()),
1255             _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields"),
1256         };
1257
1258         let mut remaining_fields = variant
1259             .fields
1260             .iter()
1261             .enumerate()
1262             .map(|(i, field)| (field.ident.normalize_to_macros_2_0(), (i, field)))
1263             .collect::<FxHashMap<_, _>>();
1264
1265         let mut seen_fields = FxHashMap::default();
1266
1267         let mut error_happened = false;
1268
1269         // Type-check each field.
1270         for field in ast_fields {
1271             let ident = tcx.adjust_ident(field.ident, variant.def_id);
1272             let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
1273                 seen_fields.insert(ident, field.span);
1274                 self.write_field_index(field.hir_id, i);
1275
1276                 // We don't look at stability attributes on
1277                 // struct-like enums (yet...), but it's definitely not
1278                 // a bug to have constructed one.
1279                 if adt_kind != AdtKind::Enum {
1280                     tcx.check_stability(v_field.did, Some(expr_id), field.span, None);
1281                 }
1282
1283                 self.field_ty(field.span, v_field, substs)
1284             } else {
1285                 error_happened = true;
1286                 if let Some(prev_span) = seen_fields.get(&ident) {
1287                     tcx.sess.emit_err(FieldMultiplySpecifiedInInitializer {
1288                         span: field.ident.span,
1289                         prev_span: *prev_span,
1290                         ident,
1291                     });
1292                 } else {
1293                     self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name, span);
1294                 }
1295
1296                 tcx.ty_error()
1297             };
1298
1299             // Make sure to give a type to the field even if there's
1300             // an error, so we can continue type-checking.
1301             self.check_expr_coercable_to_type(&field.expr, field_type, None);
1302         }
1303
1304         // Make sure the programmer specified correct number of fields.
1305         if kind_name == "union" {
1306             if ast_fields.len() != 1 {
1307                 tcx.sess.span_err(span, "union expressions should have exactly one field");
1308             }
1309         } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
1310             let no_accessible_remaining_fields = remaining_fields
1311                 .iter()
1312                 .find(|(_, (_, field))| {
1313                     field.vis.is_accessible_from(tcx.parent_module(expr_id).to_def_id(), tcx)
1314                 })
1315                 .is_none();
1316
1317             if no_accessible_remaining_fields {
1318                 self.report_no_accessible_fields(adt_ty, span);
1319             } else {
1320                 self.report_missing_fields(adt_ty, span, remaining_fields);
1321             }
1322         }
1323
1324         error_happened
1325     }
1326
1327     fn check_struct_fields_on_error(
1328         &self,
1329         fields: &'tcx [hir::ExprField<'tcx>],
1330         base_expr: &'tcx Option<&'tcx hir::Expr<'tcx>>,
1331     ) {
1332         for field in fields {
1333             self.check_expr(&field.expr);
1334         }
1335         if let Some(base) = *base_expr {
1336             self.check_expr(&base);
1337         }
1338     }
1339
1340     /// Report an error for a struct field expression when there are fields which aren't provided.
1341     ///
1342     /// ```text
1343     /// error: missing field `you_can_use_this_field` in initializer of `foo::Foo`
1344     ///  --> src/main.rs:8:5
1345     ///   |
1346     /// 8 |     foo::Foo {};
1347     ///   |     ^^^^^^^^ missing `you_can_use_this_field`
1348     ///
1349     /// error: aborting due to previous error
1350     /// ```
1351     fn report_missing_fields(
1352         &self,
1353         adt_ty: Ty<'tcx>,
1354         span: Span,
1355         remaining_fields: FxHashMap<Ident, (usize, &ty::FieldDef)>,
1356     ) {
1357         let len = remaining_fields.len();
1358
1359         let mut displayable_field_names =
1360             remaining_fields.keys().map(|ident| ident.as_str()).collect::<Vec<_>>();
1361
1362         displayable_field_names.sort();
1363
1364         let mut truncated_fields_error = String::new();
1365         let remaining_fields_names = match &displayable_field_names[..] {
1366             [field1] => format!("`{}`", field1),
1367             [field1, field2] => format!("`{}` and `{}`", field1, field2),
1368             [field1, field2, field3] => format!("`{}`, `{}` and `{}`", field1, field2, field3),
1369             _ => {
1370                 truncated_fields_error =
1371                     format!(" and {} other field{}", len - 3, pluralize!(len - 3));
1372                 displayable_field_names
1373                     .iter()
1374                     .take(3)
1375                     .map(|n| format!("`{}`", n))
1376                     .collect::<Vec<_>>()
1377                     .join(", ")
1378             }
1379         };
1380
1381         struct_span_err!(
1382             self.tcx.sess,
1383             span,
1384             E0063,
1385             "missing field{} {}{} in initializer of `{}`",
1386             pluralize!(len),
1387             remaining_fields_names,
1388             truncated_fields_error,
1389             adt_ty
1390         )
1391         .span_label(span, format!("missing {}{}", remaining_fields_names, truncated_fields_error))
1392         .emit();
1393     }
1394
1395     /// Report an error for a struct field expression when there are no visible fields.
1396     ///
1397     /// ```text
1398     /// error: cannot construct `Foo` with struct literal syntax due to inaccessible fields
1399     ///  --> src/main.rs:8:5
1400     ///   |
1401     /// 8 |     foo::Foo {};
1402     ///   |     ^^^^^^^^
1403     ///
1404     /// error: aborting due to previous error
1405     /// ```
1406     fn report_no_accessible_fields(&self, adt_ty: Ty<'tcx>, span: Span) {
1407         self.tcx.sess.span_err(
1408             span,
1409             &format!(
1410                 "cannot construct `{}` with struct literal syntax due to inaccessible fields",
1411                 adt_ty,
1412             ),
1413         );
1414     }
1415
1416     fn report_unknown_field(
1417         &self,
1418         ty: Ty<'tcx>,
1419         variant: &'tcx ty::VariantDef,
1420         field: &hir::ExprField<'_>,
1421         skip_fields: &[hir::ExprField<'_>],
1422         kind_name: &str,
1423         ty_span: Span,
1424     ) {
1425         if variant.is_recovered() {
1426             self.set_tainted_by_errors();
1427             return;
1428         }
1429         let mut err = self.type_error_struct_with_diag(
1430             field.ident.span,
1431             |actual| match ty.kind() {
1432                 ty::Adt(adt, ..) if adt.is_enum() => struct_span_err!(
1433                     self.tcx.sess,
1434                     field.ident.span,
1435                     E0559,
1436                     "{} `{}::{}` has no field named `{}`",
1437                     kind_name,
1438                     actual,
1439                     variant.ident,
1440                     field.ident
1441                 ),
1442                 _ => struct_span_err!(
1443                     self.tcx.sess,
1444                     field.ident.span,
1445                     E0560,
1446                     "{} `{}` has no field named `{}`",
1447                     kind_name,
1448                     actual,
1449                     field.ident
1450                 ),
1451             },
1452             ty,
1453         );
1454         match variant.ctor_kind {
1455             CtorKind::Fn => match ty.kind() {
1456                 ty::Adt(adt, ..) if adt.is_enum() => {
1457                     err.span_label(
1458                         variant.ident.span,
1459                         format!(
1460                             "`{adt}::{variant}` defined here",
1461                             adt = ty,
1462                             variant = variant.ident,
1463                         ),
1464                     );
1465                     err.span_label(field.ident.span, "field does not exist");
1466                     err.span_suggestion(
1467                         ty_span,
1468                         &format!(
1469                             "`{adt}::{variant}` is a tuple {kind_name}, use the appropriate syntax",
1470                             adt = ty,
1471                             variant = variant.ident,
1472                         ),
1473                         format!(
1474                             "{adt}::{variant}(/* fields */)",
1475                             adt = ty,
1476                             variant = variant.ident,
1477                         ),
1478                         Applicability::HasPlaceholders,
1479                     );
1480                 }
1481                 _ => {
1482                     err.span_label(variant.ident.span, format!("`{adt}` defined here", adt = ty));
1483                     err.span_label(field.ident.span, "field does not exist");
1484                     err.span_suggestion(
1485                         ty_span,
1486                         &format!(
1487                             "`{adt}` is a tuple {kind_name}, use the appropriate syntax",
1488                             adt = ty,
1489                             kind_name = kind_name,
1490                         ),
1491                         format!("{adt}(/* fields */)", adt = ty),
1492                         Applicability::HasPlaceholders,
1493                     );
1494                 }
1495             },
1496             _ => {
1497                 // prevent all specified fields from being suggested
1498                 let skip_fields = skip_fields.iter().map(|x| x.ident.name);
1499                 if let Some(field_name) =
1500                     Self::suggest_field_name(variant, field.ident.name, skip_fields.collect())
1501                 {
1502                     err.span_suggestion(
1503                         field.ident.span,
1504                         "a field with a similar name exists",
1505                         field_name.to_string(),
1506                         Applicability::MaybeIncorrect,
1507                     );
1508                 } else {
1509                     match ty.kind() {
1510                         ty::Adt(adt, ..) => {
1511                             if adt.is_enum() {
1512                                 err.span_label(
1513                                     field.ident.span,
1514                                     format!("`{}::{}` does not have this field", ty, variant.ident),
1515                                 );
1516                             } else {
1517                                 err.span_label(
1518                                     field.ident.span,
1519                                     format!("`{}` does not have this field", ty),
1520                                 );
1521                             }
1522                             let available_field_names = self.available_field_names(variant);
1523                             if !available_field_names.is_empty() {
1524                                 err.note(&format!(
1525                                     "available fields are: {}",
1526                                     self.name_series_display(available_field_names)
1527                                 ));
1528                             }
1529                         }
1530                         _ => bug!("non-ADT passed to report_unknown_field"),
1531                     }
1532                 };
1533             }
1534         }
1535         err.emit();
1536     }
1537
1538     // Return an hint about the closest match in field names
1539     fn suggest_field_name(
1540         variant: &'tcx ty::VariantDef,
1541         field: Symbol,
1542         skip: Vec<Symbol>,
1543     ) -> Option<Symbol> {
1544         let names = variant
1545             .fields
1546             .iter()
1547             .filter_map(|field| {
1548                 // ignore already set fields and private fields from non-local crates
1549                 if skip.iter().any(|&x| x == field.ident.name)
1550                     || (!variant.def_id.is_local() && field.vis != Visibility::Public)
1551                 {
1552                     None
1553                 } else {
1554                     Some(field.ident.name)
1555                 }
1556             })
1557             .collect::<Vec<Symbol>>();
1558
1559         find_best_match_for_name(&names, field, None)
1560     }
1561
1562     fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<Symbol> {
1563         variant
1564             .fields
1565             .iter()
1566             .filter(|field| {
1567                 let def_scope = self
1568                     .tcx
1569                     .adjust_ident_and_get_scope(field.ident, variant.def_id, self.body_id)
1570                     .1;
1571                 field.vis.is_accessible_from(def_scope, self.tcx)
1572             })
1573             .map(|field| field.ident.name)
1574             .collect()
1575     }
1576
1577     fn name_series_display(&self, names: Vec<Symbol>) -> String {
1578         // dynamic limit, to never omit just one field
1579         let limit = if names.len() == 6 { 6 } else { 5 };
1580         let mut display =
1581             names.iter().take(limit).map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
1582         if names.len() > limit {
1583             display = format!("{} ... and {} others", display, names.len() - limit);
1584         }
1585         display
1586     }
1587
1588     // Check field access expressions
1589     fn check_field(
1590         &self,
1591         expr: &'tcx hir::Expr<'tcx>,
1592         base: &'tcx hir::Expr<'tcx>,
1593         field: Ident,
1594     ) -> Ty<'tcx> {
1595         debug!("check_field(expr: {:?}, base: {:?}, field: {:?})", expr, base, field);
1596         let expr_t = self.check_expr(base);
1597         let expr_t = self.structurally_resolved_type(base.span, expr_t);
1598         let mut private_candidate = None;
1599         let mut autoderef = self.autoderef(expr.span, expr_t);
1600         while let Some((base_t, _)) = autoderef.next() {
1601             debug!("base_t: {:?}", base_t);
1602             match base_t.kind() {
1603                 ty::Adt(base_def, substs) if !base_def.is_enum() => {
1604                     debug!("struct named {:?}", base_t);
1605                     let (ident, def_scope) =
1606                         self.tcx.adjust_ident_and_get_scope(field, base_def.did, self.body_id);
1607                     let fields = &base_def.non_enum_variant().fields;
1608                     if let Some(index) =
1609                         fields.iter().position(|f| f.ident.normalize_to_macros_2_0() == ident)
1610                     {
1611                         let field = &fields[index];
1612                         let field_ty = self.field_ty(expr.span, field, substs);
1613                         // Save the index of all fields regardless of their visibility in case
1614                         // of error recovery.
1615                         self.write_field_index(expr.hir_id, index);
1616                         if field.vis.is_accessible_from(def_scope, self.tcx) {
1617                             let adjustments = self.adjust_steps(&autoderef);
1618                             self.apply_adjustments(base, adjustments);
1619                             self.register_predicates(autoderef.into_obligations());
1620
1621                             self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span, None);
1622                             return field_ty;
1623                         }
1624                         private_candidate = Some((base_def.did, field_ty));
1625                     }
1626                 }
1627                 ty::Tuple(tys) => {
1628                     let fstr = field.as_str();
1629                     if let Ok(index) = fstr.parse::<usize>() {
1630                         if fstr == index.to_string() {
1631                             if let Some(field_ty) = tys.get(index) {
1632                                 let adjustments = self.adjust_steps(&autoderef);
1633                                 self.apply_adjustments(base, adjustments);
1634                                 self.register_predicates(autoderef.into_obligations());
1635
1636                                 self.write_field_index(expr.hir_id, index);
1637                                 return field_ty.expect_ty();
1638                             }
1639                         }
1640                     }
1641                 }
1642                 _ => {}
1643             }
1644         }
1645         self.structurally_resolved_type(autoderef.span(), autoderef.final_ty(false));
1646
1647         if let Some((did, field_ty)) = private_candidate {
1648             self.ban_private_field_access(expr, expr_t, field, did);
1649             return field_ty;
1650         }
1651
1652         if field.name == kw::Empty {
1653         } else if self.method_exists(field, expr_t, expr.hir_id, true) {
1654             self.ban_take_value_of_method(expr, expr_t, field);
1655         } else if !expr_t.is_primitive_ty() {
1656             self.ban_nonexisting_field(field, base, expr, expr_t);
1657         } else {
1658             type_error_struct!(
1659                 self.tcx().sess,
1660                 field.span,
1661                 expr_t,
1662                 E0610,
1663                 "`{}` is a primitive type and therefore doesn't have fields",
1664                 expr_t
1665             )
1666             .emit();
1667         }
1668
1669         self.tcx().ty_error()
1670     }
1671
1672     fn suggest_await_on_field_access(
1673         &self,
1674         err: &mut DiagnosticBuilder<'_>,
1675         field_ident: Ident,
1676         base: &'tcx hir::Expr<'tcx>,
1677         ty: Ty<'tcx>,
1678     ) {
1679         let output_ty = match self.infcx.get_impl_future_output_ty(ty) {
1680             Some(output_ty) => self.resolve_vars_if_possible(output_ty),
1681             _ => return,
1682         };
1683         let mut add_label = true;
1684         if let ty::Adt(def, _) = output_ty.kind() {
1685             // no field access on enum type
1686             if !def.is_enum() {
1687                 if def.non_enum_variant().fields.iter().any(|field| field.ident == field_ident) {
1688                     add_label = false;
1689                     err.span_label(
1690                         field_ident.span,
1691                         "field not available in `impl Future`, but it is available in its `Output`",
1692                     );
1693                     err.span_suggestion_verbose(
1694                         base.span.shrink_to_hi(),
1695                         "consider `await`ing on the `Future` and access the field of its `Output`",
1696                         ".await".to_string(),
1697                         Applicability::MaybeIncorrect,
1698                     );
1699                 }
1700             }
1701         }
1702         if add_label {
1703             err.span_label(field_ident.span, &format!("field not found in `{}`", ty));
1704         }
1705     }
1706
1707     fn ban_nonexisting_field(
1708         &self,
1709         field: Ident,
1710         base: &'tcx hir::Expr<'tcx>,
1711         expr: &'tcx hir::Expr<'tcx>,
1712         expr_t: Ty<'tcx>,
1713     ) {
1714         debug!(
1715             "ban_nonexisting_field: field={:?}, base={:?}, expr={:?}, expr_ty={:?}",
1716             field, base, expr, expr_t
1717         );
1718         let mut err = self.no_such_field_err(field, expr_t);
1719
1720         match *expr_t.peel_refs().kind() {
1721             ty::Array(_, len) => {
1722                 self.maybe_suggest_array_indexing(&mut err, expr, base, field, len);
1723             }
1724             ty::RawPtr(..) => {
1725                 self.suggest_first_deref_field(&mut err, expr, base, field);
1726             }
1727             ty::Adt(def, _) if !def.is_enum() => {
1728                 self.suggest_fields_on_recordish(&mut err, def, field);
1729             }
1730             ty::Param(param_ty) => {
1731                 self.point_at_param_definition(&mut err, param_ty);
1732             }
1733             ty::Opaque(_, _) => {
1734                 self.suggest_await_on_field_access(&mut err, field, base, expr_t.peel_refs());
1735             }
1736             _ => {}
1737         }
1738
1739         if field.name == kw::Await {
1740             // We know by construction that `<expr>.await` is either on Rust 2015
1741             // or results in `ExprKind::Await`. Suggest switching the edition to 2018.
1742             err.note("to `.await` a `Future`, switch to Rust 2018 or later");
1743             err.help(&format!("set `edition = \"{}\"` in `Cargo.toml`", LATEST_STABLE_EDITION));
1744             err.note("for more on editions, read https://doc.rust-lang.org/edition-guide");
1745         }
1746
1747         err.emit();
1748     }
1749
1750     fn ban_private_field_access(
1751         &self,
1752         expr: &hir::Expr<'_>,
1753         expr_t: Ty<'tcx>,
1754         field: Ident,
1755         base_did: DefId,
1756     ) {
1757         let struct_path = self.tcx().def_path_str(base_did);
1758         let kind_name = self.tcx().def_kind(base_did).descr(base_did);
1759         let mut err = struct_span_err!(
1760             self.tcx().sess,
1761             field.span,
1762             E0616,
1763             "field `{}` of {} `{}` is private",
1764             field,
1765             kind_name,
1766             struct_path
1767         );
1768         err.span_label(field.span, "private field");
1769         // Also check if an accessible method exists, which is often what is meant.
1770         if self.method_exists(field, expr_t, expr.hir_id, false) && !self.expr_in_place(expr.hir_id)
1771         {
1772             self.suggest_method_call(
1773                 &mut err,
1774                 &format!("a method `{}` also exists, call it with parentheses", field),
1775                 field,
1776                 expr_t,
1777                 expr,
1778             );
1779         }
1780         err.emit();
1781     }
1782
1783     fn ban_take_value_of_method(&self, expr: &hir::Expr<'_>, expr_t: Ty<'tcx>, field: Ident) {
1784         let mut err = type_error_struct!(
1785             self.tcx().sess,
1786             field.span,
1787             expr_t,
1788             E0615,
1789             "attempted to take value of method `{}` on type `{}`",
1790             field,
1791             expr_t
1792         );
1793         err.span_label(field.span, "method, not a field");
1794         if !self.expr_in_place(expr.hir_id) {
1795             self.suggest_method_call(
1796                 &mut err,
1797                 "use parentheses to call the method",
1798                 field,
1799                 expr_t,
1800                 expr,
1801             );
1802         } else {
1803             err.help("methods are immutable and cannot be assigned to");
1804         }
1805
1806         err.emit();
1807     }
1808
1809     fn point_at_param_definition(&self, err: &mut DiagnosticBuilder<'_>, param: ty::ParamTy) {
1810         let generics = self.tcx.generics_of(self.body_id.owner.to_def_id());
1811         let generic_param = generics.type_param(&param, self.tcx);
1812         if let ty::GenericParamDefKind::Type { synthetic: Some(..), .. } = generic_param.kind {
1813             return;
1814         }
1815         let param_def_id = generic_param.def_id;
1816         let param_hir_id = match param_def_id.as_local() {
1817             Some(x) => self.tcx.hir().local_def_id_to_hir_id(x),
1818             None => return,
1819         };
1820         let param_span = self.tcx.hir().span(param_hir_id);
1821         let param_name = self.tcx.hir().ty_param_name(param_hir_id);
1822
1823         err.span_label(param_span, &format!("type parameter '{}' declared here", param_name));
1824     }
1825
1826     fn suggest_fields_on_recordish(
1827         &self,
1828         err: &mut DiagnosticBuilder<'_>,
1829         def: &'tcx ty::AdtDef,
1830         field: Ident,
1831     ) {
1832         if let Some(suggested_field_name) =
1833             Self::suggest_field_name(def.non_enum_variant(), field.name, vec![])
1834         {
1835             err.span_suggestion(
1836                 field.span,
1837                 "a field with a similar name exists",
1838                 suggested_field_name.to_string(),
1839                 Applicability::MaybeIncorrect,
1840             );
1841         } else {
1842             err.span_label(field.span, "unknown field");
1843             let struct_variant_def = def.non_enum_variant();
1844             let field_names = self.available_field_names(struct_variant_def);
1845             if !field_names.is_empty() {
1846                 err.note(&format!(
1847                     "available fields are: {}",
1848                     self.name_series_display(field_names),
1849                 ));
1850             }
1851         }
1852     }
1853
1854     fn maybe_suggest_array_indexing(
1855         &self,
1856         err: &mut DiagnosticBuilder<'_>,
1857         expr: &hir::Expr<'_>,
1858         base: &hir::Expr<'_>,
1859         field: Ident,
1860         len: &ty::Const<'tcx>,
1861     ) {
1862         if let (Some(len), Ok(user_index)) =
1863             (len.try_eval_usize(self.tcx, self.param_env), field.as_str().parse::<u64>())
1864         {
1865             if let Ok(base) = self.tcx.sess.source_map().span_to_snippet(base.span) {
1866                 let help = "instead of using tuple indexing, use array indexing";
1867                 let suggestion = format!("{}[{}]", base, field);
1868                 let applicability = if len < user_index {
1869                     Applicability::MachineApplicable
1870                 } else {
1871                     Applicability::MaybeIncorrect
1872                 };
1873                 err.span_suggestion(expr.span, help, suggestion, applicability);
1874             }
1875         }
1876     }
1877
1878     fn suggest_first_deref_field(
1879         &self,
1880         err: &mut DiagnosticBuilder<'_>,
1881         expr: &hir::Expr<'_>,
1882         base: &hir::Expr<'_>,
1883         field: Ident,
1884     ) {
1885         if let Ok(base) = self.tcx.sess.source_map().span_to_snippet(base.span) {
1886             let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
1887             let suggestion = format!("(*{}).{}", base, field);
1888             err.span_suggestion(expr.span, &msg, suggestion, Applicability::MaybeIncorrect);
1889         }
1890     }
1891
1892     fn no_such_field_err(
1893         &self,
1894         field: Ident,
1895         expr_t: &'tcx ty::TyS<'tcx>,
1896     ) -> DiagnosticBuilder<'_> {
1897         let span = field.span;
1898         debug!("no_such_field_err(span: {:?}, field: {:?}, expr_t: {:?})", span, field, expr_t);
1899
1900         let mut err = type_error_struct!(
1901             self.tcx().sess,
1902             field.span,
1903             expr_t,
1904             E0609,
1905             "no field `{}` on type `{}`",
1906             field,
1907             expr_t
1908         );
1909
1910         // try to add a suggestion in case the field is a nested field of a field of the Adt
1911         if let Some((fields, substs)) = self.get_field_candidates(span, &expr_t) {
1912             for candidate_field in fields.iter() {
1913                 if let Some(field_path) =
1914                     self.check_for_nested_field(span, field, candidate_field, substs, vec![])
1915                 {
1916                     let field_path_str = field_path
1917                         .iter()
1918                         .map(|id| id.name.to_ident_string())
1919                         .collect::<Vec<String>>()
1920                         .join(".");
1921                     debug!("field_path_str: {:?}", field_path_str);
1922
1923                     err.span_suggestion_verbose(
1924                         field.span.shrink_to_lo(),
1925                         "one of the expressions' fields has a field of the same name",
1926                         format!("{}.", field_path_str),
1927                         Applicability::MaybeIncorrect,
1928                     );
1929                 }
1930             }
1931         }
1932         err
1933     }
1934
1935     fn get_field_candidates(
1936         &self,
1937         span: Span,
1938         base_t: Ty<'tcx>,
1939     ) -> Option<(&Vec<ty::FieldDef>, SubstsRef<'tcx>)> {
1940         debug!("get_field_candidates(span: {:?}, base_t: {:?}", span, base_t);
1941
1942         let mut autoderef = self.autoderef(span, base_t);
1943         while let Some((base_t, _)) = autoderef.next() {
1944             match base_t.kind() {
1945                 ty::Adt(base_def, substs) if !base_def.is_enum() => {
1946                     let fields = &base_def.non_enum_variant().fields;
1947                     // For compile-time reasons put a limit on number of fields we search
1948                     if fields.len() > 100 {
1949                         return None;
1950                     }
1951                     return Some((fields, substs));
1952                 }
1953                 _ => {}
1954             }
1955         }
1956         None
1957     }
1958
1959     /// This method is called after we have encountered a missing field error to recursively
1960     /// search for the field
1961     fn check_for_nested_field(
1962         &self,
1963         span: Span,
1964         target_field: Ident,
1965         candidate_field: &ty::FieldDef,
1966         subst: SubstsRef<'tcx>,
1967         mut field_path: Vec<Ident>,
1968     ) -> Option<Vec<Ident>> {
1969         debug!(
1970             "check_for_nested_field(span: {:?}, candidate_field: {:?}, field_path: {:?}",
1971             span, candidate_field, field_path
1972         );
1973
1974         if candidate_field.ident == target_field {
1975             Some(field_path)
1976         } else if field_path.len() > 3 {
1977             // For compile-time reasons and to avoid infinite recursion we only check for fields
1978             // up to a depth of three
1979             None
1980         } else {
1981             // recursively search fields of `candidate_field` if it's a ty::Adt
1982
1983             field_path.push(candidate_field.ident.normalize_to_macros_2_0());
1984             let field_ty = candidate_field.ty(self.tcx, subst);
1985             if let Some((nested_fields, subst)) = self.get_field_candidates(span, &field_ty) {
1986                 for field in nested_fields.iter() {
1987                     let ident = field.ident.normalize_to_macros_2_0();
1988                     if ident == target_field {
1989                         return Some(field_path);
1990                     } else {
1991                         let field_path = field_path.clone();
1992                         if let Some(path) = self.check_for_nested_field(
1993                             span,
1994                             target_field,
1995                             field,
1996                             subst,
1997                             field_path,
1998                         ) {
1999                             return Some(path);
2000                         }
2001                     }
2002                 }
2003             }
2004             None
2005         }
2006     }
2007
2008     fn check_expr_index(
2009         &self,
2010         base: &'tcx hir::Expr<'tcx>,
2011         idx: &'tcx hir::Expr<'tcx>,
2012         expr: &'tcx hir::Expr<'tcx>,
2013     ) -> Ty<'tcx> {
2014         let base_t = self.check_expr(&base);
2015         let idx_t = self.check_expr(&idx);
2016
2017         if base_t.references_error() {
2018             base_t
2019         } else if idx_t.references_error() {
2020             idx_t
2021         } else {
2022             let base_t = self.structurally_resolved_type(base.span, base_t);
2023             match self.lookup_indexing(expr, base, base_t, idx_t) {
2024                 Some((index_ty, element_ty)) => {
2025                     // two-phase not needed because index_ty is never mutable
2026                     self.demand_coerce(idx, idx_t, index_ty, None, AllowTwoPhase::No);
2027                     element_ty
2028                 }
2029                 None => {
2030                     let mut err = type_error_struct!(
2031                         self.tcx.sess,
2032                         expr.span,
2033                         base_t,
2034                         E0608,
2035                         "cannot index into a value of type `{}`",
2036                         base_t
2037                     );
2038                     // Try to give some advice about indexing tuples.
2039                     if let ty::Tuple(..) = base_t.kind() {
2040                         let mut needs_note = true;
2041                         // If the index is an integer, we can show the actual
2042                         // fixed expression:
2043                         if let ExprKind::Lit(ref lit) = idx.kind {
2044                             if let ast::LitKind::Int(i, ast::LitIntType::Unsuffixed) = lit.node {
2045                                 let snip = self.tcx.sess.source_map().span_to_snippet(base.span);
2046                                 if let Ok(snip) = snip {
2047                                     err.span_suggestion(
2048                                         expr.span,
2049                                         "to access tuple elements, use",
2050                                         format!("{}.{}", snip, i),
2051                                         Applicability::MachineApplicable,
2052                                     );
2053                                     needs_note = false;
2054                                 }
2055                             }
2056                         }
2057                         if needs_note {
2058                             err.help(
2059                                 "to access tuple elements, use tuple indexing \
2060                                         syntax (e.g., `tuple.0`)",
2061                             );
2062                         }
2063                     }
2064                     err.emit();
2065                     self.tcx.ty_error()
2066                 }
2067             }
2068         }
2069     }
2070
2071     fn check_expr_yield(
2072         &self,
2073         value: &'tcx hir::Expr<'tcx>,
2074         expr: &'tcx hir::Expr<'tcx>,
2075         src: &'tcx hir::YieldSource,
2076     ) -> Ty<'tcx> {
2077         match self.resume_yield_tys {
2078             Some((resume_ty, yield_ty)) => {
2079                 self.check_expr_coercable_to_type(&value, yield_ty, None);
2080
2081                 resume_ty
2082             }
2083             // Given that this `yield` expression was generated as a result of lowering a `.await`,
2084             // we know that the yield type must be `()`; however, the context won't contain this
2085             // information. Hence, we check the source of the yield expression here and check its
2086             // value's type against `()` (this check should always hold).
2087             None if src.is_await() => {
2088                 self.check_expr_coercable_to_type(&value, self.tcx.mk_unit(), None);
2089                 self.tcx.mk_unit()
2090             }
2091             _ => {
2092                 self.tcx.sess.emit_err(YieldExprOutsideOfGenerator { span: expr.span });
2093                 // Avoid expressions without types during writeback (#78653).
2094                 self.check_expr(value);
2095                 self.tcx.mk_unit()
2096             }
2097         }
2098     }
2099
2100     fn check_expr_asm_operand(&self, expr: &'tcx hir::Expr<'tcx>, is_input: bool) {
2101         let needs = if is_input { Needs::None } else { Needs::MutPlace };
2102         let ty = self.check_expr_with_needs(expr, needs);
2103         self.require_type_is_sized(ty, expr.span, traits::InlineAsmSized);
2104
2105         if !is_input && !expr.is_syntactic_place_expr() {
2106             let mut err = self.tcx.sess.struct_span_err(expr.span, "invalid asm output");
2107             err.span_label(expr.span, "cannot assign to this expression");
2108             err.emit();
2109         }
2110
2111         // If this is an input value, we require its type to be fully resolved
2112         // at this point. This allows us to provide helpful coercions which help
2113         // pass the type candidate list in a later pass.
2114         //
2115         // We don't require output types to be resolved at this point, which
2116         // allows them to be inferred based on how they are used later in the
2117         // function.
2118         if is_input {
2119             let ty = self.structurally_resolved_type(expr.span, &ty);
2120             match *ty.kind() {
2121                 ty::FnDef(..) => {
2122                     let fnptr_ty = self.tcx.mk_fn_ptr(ty.fn_sig(self.tcx));
2123                     self.demand_coerce(expr, ty, fnptr_ty, None, AllowTwoPhase::No);
2124                 }
2125                 ty::Ref(_, base_ty, mutbl) => {
2126                     let ptr_ty = self.tcx.mk_ptr(ty::TypeAndMut { ty: base_ty, mutbl });
2127                     self.demand_coerce(expr, ty, ptr_ty, None, AllowTwoPhase::No);
2128                 }
2129                 _ => {}
2130             }
2131         }
2132     }
2133
2134     fn check_expr_asm(&self, asm: &'tcx hir::InlineAsm<'tcx>) -> Ty<'tcx> {
2135         for (op, _op_sp) in asm.operands {
2136             match op {
2137                 hir::InlineAsmOperand::In { expr, .. } => {
2138                     self.check_expr_asm_operand(expr, true);
2139                 }
2140                 hir::InlineAsmOperand::Out { expr, .. } => {
2141                     if let Some(expr) = expr {
2142                         self.check_expr_asm_operand(expr, false);
2143                     }
2144                 }
2145                 hir::InlineAsmOperand::InOut { expr, .. } => {
2146                     self.check_expr_asm_operand(expr, false);
2147                 }
2148                 hir::InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
2149                     self.check_expr_asm_operand(in_expr, true);
2150                     if let Some(out_expr) = out_expr {
2151                         self.check_expr_asm_operand(out_expr, false);
2152                     }
2153                 }
2154                 hir::InlineAsmOperand::Const { anon_const } => {
2155                     self.to_const(anon_const);
2156                 }
2157                 hir::InlineAsmOperand::Sym { expr } => {
2158                     self.check_expr(expr);
2159                 }
2160             }
2161         }
2162         if asm.options.contains(ast::InlineAsmOptions::NORETURN) {
2163             self.tcx.types.never
2164         } else {
2165             self.tcx.mk_unit()
2166         }
2167     }
2168 }
2169
2170 pub(super) fn ty_kind_suggestion(ty: Ty<'_>) -> Option<&'static str> {
2171     Some(match ty.kind() {
2172         ty::Bool => "true",
2173         ty::Char => "'a'",
2174         ty::Int(_) | ty::Uint(_) => "42",
2175         ty::Float(_) => "3.14159",
2176         ty::Error(_) | ty::Never => return None,
2177         _ => "value",
2178     })
2179 }