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: expr={:?} expected={:?}", expr, expected);
 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(expr={:?}, expected={:?})", expr, expected);
 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, None);
 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) = self.resolve_ty_and_res_ufcs(qpath, expr.hir_id, expr.span);
 470         let ty = match res {
 471             Res::Err => {
 472                 self.set_tainted_by_errors();
 473                 tcx.ty_error()
 474             }
 475             Res::Def(DefKind::Ctor(_, CtorKind::Fictive), _) => {
 476                 report_unexpected_variant_res(tcx, res, expr.span);
 477                 tcx.ty_error()
 478             }
 479             _ => self.instantiate_value_path(segs, opt_ty, res, expr.span, expr.hir_id).0,
 480         };
 481
 482         if let ty::FnDef(..) = ty.kind() {
 483             let fn_sig = ty.fn_sig(tcx);
 484             if !tcx.features().unsized_fn_params {
 485                 // We want to remove some Sized bounds from std functions,
 486                 // but don't want to expose the removal to stable Rust.
 487                 // i.e., we don't want to allow
 488                 //
 489                 // ```rust
 490                 // drop as fn(str);
 491                 // ```
 492                 //
 493                 // to work in stable even if the Sized bound on `drop` is relaxed.
 494                 for i in 0..fn_sig.inputs().skip_binder().len() {
 495                     // We just want to check sizedness, so instead of introducing
 496                     // placeholder lifetimes with probing, we just replace higher lifetimes
 497                     // with fresh vars.
 498                     let input = self
 499                         .replace_bound_vars_with_fresh_vars(
 500                             expr.span,
 501                             infer::LateBoundRegionConversionTime::FnCall,
 502                             fn_sig.input(i),
 503                         )
 504                         .0;
 505                     self.require_type_is_sized_deferred(
 506                         input,
 507                         expr.span,
 508                         traits::SizedArgumentType(None),
 509                     );
 510                 }
 511             }
 512             // Here we want to prevent struct constructors from returning unsized types.
 513             // There were two cases this happened: fn pointer coercion in stable
 514             // and usual function call in presence of unsized_locals.
 515             // Also, as we just want to check sizedness, instead of introducing
 516             // placeholder lifetimes with probing, we just replace higher lifetimes
 517             // with fresh vars.
 518             let output = self
 519                 .replace_bound_vars_with_fresh_vars(
 520                     expr.span,
 521                     infer::LateBoundRegionConversionTime::FnCall,
 522                     fn_sig.output(),
 523                 )
 524                 .0;
 525             self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
 526         }
 527
 528         // We always require that the type provided as the value for
 529         // a type parameter outlives the moment of instantiation.
 530         let substs = self.typeck_results.borrow().node_substs(expr.hir_id);
 531         self.add_wf_bounds(substs, expr);
 532
 533         ty
 534     }
 535
 536     fn check_expr_break(
 537         &self,
 538         destination: hir::Destination,
 539         expr_opt: Option<&'tcx hir::Expr<'tcx>>,
 540         expr: &'tcx hir::Expr<'tcx>,
 541     ) -> Ty<'tcx> {
 542         let tcx = self.tcx;
 543         if let Ok(target_id) = destination.target_id {
 544             let (e_ty, cause);
 545             if let Some(e) = expr_opt {
 546                 // If this is a break with a value, we need to type-check
 547                 // the expression. Get an expected type from the loop context.
 548                 let opt_coerce_to = {
 549                     // We should release `enclosing_breakables` before the `check_expr_with_hint`
 550                     // below, so can't move this block of code to the enclosing scope and share
 551                     // `ctxt` with the second `encloding_breakables` borrow below.
 552                     let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
 553                     match enclosing_breakables.opt_find_breakable(target_id) {
 554                         Some(ctxt) => ctxt.coerce.as_ref().map(|coerce| coerce.expected_ty()),
 555                         None => {
 556                             // Avoid ICE when `break` is inside a closure (#65383).
 557                             return tcx.ty_error_with_message(
 558                                 expr.span,
 559                                 "break was outside loop, but no error was emitted",
 560                             );
 561                         }
 562                     }
 563                 };
 564
 565                 // If the loop context is not a `loop { }`, then break with
 566                 // a value is illegal, and `opt_coerce_to` will be `None`.
 567                 // Just set expectation to error in that case.
 568                 let coerce_to = opt_coerce_to.unwrap_or_else(|| tcx.ty_error());
 569
 570                 // Recurse without `enclosing_breakables` borrowed.
 571                 e_ty = self.check_expr_with_hint(e, coerce_to);
 572                 cause = self.misc(e.span);
 573             } else {
 574                 // Otherwise, this is a break *without* a value. That's
 575                 // always legal, and is equivalent to `break ()`.
 576                 e_ty = tcx.mk_unit();
 577                 cause = self.misc(expr.span);
 578             }
 579
 580             // Now that we have type-checked `expr_opt`, borrow
 581             // the `enclosing_loops` field and let's coerce the
 582             // type of `expr_opt` into what is expected.
 583             let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
 584             let ctxt = match enclosing_breakables.opt_find_breakable(target_id) {
 585                 Some(ctxt) => ctxt,
 586                 None => {
 587                     // Avoid ICE when `break` is inside a closure (#65383).
 588                     return tcx.ty_error_with_message(
 589                         expr.span,
 590                         "break was outside loop, but no error was emitted",
 591                     );
 592                 }
 593             };
 594
 595             if let Some(ref mut coerce) = ctxt.coerce {
 596                 if let Some(ref e) = expr_opt {
 597                     coerce.coerce(self, &cause, e, e_ty);
 598                 } else {
 599                     assert!(e_ty.is_unit());
 600                     let ty = coerce.expected_ty();
 601                     coerce.coerce_forced_unit(
 602                         self,
 603                         &cause,
 604                         &mut |mut err| {
 605                             self.suggest_mismatched_types_on_tail(
 606                                 &mut err, expr, ty, e_ty, cause.span, target_id,
 607                             );
 608                             if let Some(val) = ty_kind_suggestion(ty) {
 609                                 let label = destination
 610                                     .label
 611                                     .map(|l| format!(" {}", l.ident))
 612                                     .unwrap_or_else(String::new);
 613                                 err.span_suggestion(
 614                                     expr.span,
 615                                     "give it a value of the expected type",
 616                                     format!("break{} {}", label, val),
 617                                     Applicability::HasPlaceholders,
 618                                 );
 619                             }
 620                         },
 621                         false,
 622                     );
 623                 }
 624             } else {
 625                 // If `ctxt.coerce` is `None`, we can just ignore
 626                 // the type of the expression.  This is because
 627                 // either this was a break *without* a value, in
 628                 // which case it is always a legal type (`()`), or
 629                 // else an error would have been flagged by the
 630                 // `loops` pass for using break with an expression
 631                 // where you are not supposed to.
 632                 assert!(expr_opt.is_none() || self.tcx.sess.has_errors());
 633             }
 634
 635             // If we encountered a `break`, then (no surprise) it may be possible to break from the
 636             // loop... unless the value being returned from the loop diverges itself, e.g.
 637             // `break return 5` or `break loop {}`.
 638             ctxt.may_break |= !self.diverges.get().is_always();
 639
 640             // the type of a `break` is always `!`, since it diverges
 641             tcx.types.never
 642         } else {
 643             // Otherwise, we failed to find the enclosing loop;
 644             // this can only happen if the `break` was not
 645             // inside a loop at all, which is caught by the
 646             // loop-checking pass.
 647             let err = self.tcx.ty_error_with_message(
 648                 expr.span,
 649                 "break was outside loop, but no error was emitted",
 650             );
 651
 652             // We still need to assign a type to the inner expression to
 653             // prevent the ICE in #43162.
 654             if let Some(e) = expr_opt {
 655                 self.check_expr_with_hint(e, err);
 656
 657                 // ... except when we try to 'break rust;'.
 658                 // ICE this expression in particular (see #43162).
 659                 if let ExprKind::Path(QPath::Resolved(_, path)) = e.kind {
 660                     if path.segments.len() == 1 && path.segments[0].ident.name == sym::rust {
 661                         fatally_break_rust(self.tcx.sess);
 662                     }
 663                 }
 664             }
 665
 666             // There was an error; make type-check fail.
 667             err
 668         }
 669     }
 670
 671     fn check_expr_return(
 672         &self,
 673         expr_opt: Option<&'tcx hir::Expr<'tcx>>,
 674         expr: &'tcx hir::Expr<'tcx>,
 675     ) -> Ty<'tcx> {
 676         if self.ret_coercion.is_none() {
 677             self.tcx.sess.emit_err(ReturnStmtOutsideOfFnBody { span: expr.span });
 678         } else if let Some(e) = expr_opt {
 679             if self.ret_coercion_span.get().is_none() {
 680                 self.ret_coercion_span.set(Some(e.span));
 681             }
 682             self.check_return_expr(e);
 683         } else {
 684             let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
 685             if self.ret_coercion_span.get().is_none() {
 686                 self.ret_coercion_span.set(Some(expr.span));
 687             }
 688             let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
 689             if let Some((fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
 690                 coercion.coerce_forced_unit(
 691                     self,
 692                     &cause,
 693                     &mut |db| {
 694                         let span = fn_decl.output.span();
 695                         if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
 696                             db.span_label(
 697                                 span,
 698                                 format!("expected `{}` because of this return type", snippet),
 699                             );
 700                         }
 701                     },
 702                     true,
 703                 );
 704             } else {
 705                 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
 706             }
 707         }
 708         self.tcx.types.never
 709     }
 710
 711     pub(super) fn check_return_expr(&self, return_expr: &'tcx hir::Expr<'tcx>) {
 712         let ret_coercion = self.ret_coercion.as_ref().unwrap_or_else(|| {
 713             span_bug!(return_expr.span, "check_return_expr called outside fn body")
 714         });
 715
 716         let ret_ty = ret_coercion.borrow().expected_ty();
 717         let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty);
 718         ret_coercion.borrow_mut().coerce(
 719             self,
 720             &self.cause(return_expr.span, ObligationCauseCode::ReturnValue(return_expr.hir_id)),
 721             return_expr,
 722             return_expr_ty,
 723         );
 724     }
 725
 726     pub(crate) fn check_lhs_assignable(
 727         &self,
 728         lhs: &'tcx hir::Expr<'tcx>,
 729         err_code: &'static str,
 730         expr_span: &Span,
 731     ) {
 732         if lhs.is_syntactic_place_expr() {
 733             return;
 734         }
 735
 736         // FIXME: Make this use SessionDiagnostic once error codes can be dynamically set.
 737         let mut err = self.tcx.sess.struct_span_err_with_code(
 738             *expr_span,
 739             "invalid left-hand side of assignment",
 740             DiagnosticId::Error(err_code.into()),
 741         );
 742         err.span_label(lhs.span, "cannot assign to this expression");
 743         err.emit();
 744     }
 745
 746     // A generic function for checking the 'then' and 'else' clauses in an 'if'
 747     // or 'if-else' expression.
 748     fn check_then_else(
 749         &self,
 750         cond_expr: &'tcx hir::Expr<'tcx>,
 751         then_expr: &'tcx hir::Expr<'tcx>,
 752         opt_else_expr: Option<&'tcx hir::Expr<'tcx>>,
 753         sp: Span,
 754         orig_expected: Expectation<'tcx>,
 755     ) -> Ty<'tcx> {
 756         let cond_ty = self.check_expr_has_type_or_error(cond_expr, self.tcx.types.bool, |_| {});
 757
 758         self.warn_if_unreachable(cond_expr.hir_id, then_expr.span, "block in `if` expression");
 759
 760         let cond_diverges = self.diverges.get();
 761         self.diverges.set(Diverges::Maybe);
 762
 763         let expected = orig_expected.adjust_for_branches(self);
 764         let then_ty = self.check_expr_with_expectation(then_expr, expected);
 765         let then_diverges = self.diverges.get();
 766         self.diverges.set(Diverges::Maybe);
 767
 768         // We've already taken the expected type's preferences
 769         // into account when typing the `then` branch. To figure
 770         // out the initial shot at a LUB, we thus only consider
 771         // `expected` if it represents a *hard* constraint
 772         // (`only_has_type`); otherwise, we just go with a
 773         // fresh type variable.
 774         let coerce_to_ty = expected.coercion_target_type(self, sp);
 775         let mut coerce: DynamicCoerceMany<'_> = CoerceMany::new(coerce_to_ty);
 776
 777         coerce.coerce(self, &self.misc(sp), then_expr, then_ty);
 778
 779         if let Some(else_expr) = opt_else_expr {
 780             let else_ty = self.check_expr_with_expectation(else_expr, expected);
 781             let else_diverges = self.diverges.get();
 782
 783             let opt_suggest_box_span =
 784                 self.opt_suggest_box_span(else_expr.span, else_ty, orig_expected);
 785             let if_cause =
 786                 self.if_cause(sp, then_expr, else_expr, then_ty, else_ty, opt_suggest_box_span);
 787
 788             coerce.coerce(self, &if_cause, else_expr, else_ty);
 789
 790             // We won't diverge unless both branches do (or the condition does).
 791             self.diverges.set(cond_diverges | then_diverges & else_diverges);
 792         } else {
 793             self.if_fallback_coercion(sp, then_expr, &mut coerce, |hir_id, span| {
 794                 self.maybe_get_coercion_reason_if(hir_id, span)
 795             });
 796
 797             // If the condition is false we can't diverge.
 798             self.diverges.set(cond_diverges);
 799         }
 800
 801         let result_ty = coerce.complete(self);
 802         if cond_ty.references_error() { self.tcx.ty_error() } else { result_ty }
 803     }
 804
 805     /// Type check assignment expression `expr` of form `lhs = rhs`.
 806     /// The expected type is `()` and is passed to the function for the purposes of diagnostics.
 807     fn check_expr_assign(
 808         &self,
 809         expr: &'tcx hir::Expr<'tcx>,
 810         expected: Expectation<'tcx>,
 811         lhs: &'tcx hir::Expr<'tcx>,
 812         rhs: &'tcx hir::Expr<'tcx>,
 813         span: &Span,
 814     ) -> Ty<'tcx> {
 815         let expected_ty = expected.coercion_target_type(self, expr.span);
 816         if expected_ty == self.tcx.types.bool {
 817             // The expected type is `bool` but this will result in `()` so we can reasonably
 818             // say that the user intended to write `lhs == rhs` instead of `lhs = rhs`.
 819             // The likely cause of this is `if foo = bar { .. }`.
 820             let actual_ty = self.tcx.mk_unit();
 821             let mut err = self.demand_suptype_diag(expr.span, expected_ty, actual_ty).unwrap();
 822             let lhs_ty = self.check_expr(&lhs);
 823             let rhs_ty = self.check_expr(&rhs);
 824             let (applicability, eq) = if self.can_coerce(rhs_ty, lhs_ty) {
 825                 (Applicability::MachineApplicable, true)
 826             } else {
 827                 (Applicability::MaybeIncorrect, false)
 828             };
 829             if !lhs.is_syntactic_place_expr() {
 830                 // Do not suggest `if let x = y` as `==` is way more likely to be the intention.
 831                 let mut span_err = || {
 832                     // Likely `if let` intended.
 833                     err.span_suggestion_verbose(
 834                         expr.span.shrink_to_lo(),
 835                         "you might have meant to use pattern matching",
 836                         "let ".to_string(),
 837                         applicability,
 838                     );
 839                 };
 840                 if let hir::Node::Expr(hir::Expr {
 841                     kind: ExprKind::Match(_, _, hir::MatchSource::WhileDesugar),
 842                     ..
 843                 }) = self.tcx.hir().get(
 844                     self.tcx.hir().get_parent_node(self.tcx.hir().get_parent_node(expr.hir_id)),
 845                 ) {
 846                     span_err();
 847                 } else if let hir::Node::Expr(hir::Expr { kind: ExprKind::If { .. }, .. }) =
 848                     self.tcx.hir().get(self.tcx.hir().get_parent_node(expr.hir_id))
 849                 {
 850                     span_err();
 851                 }
 852             }
 853             if eq {
 854                 err.span_suggestion_verbose(
 855                     *span,
 856                     "you might have meant to compare for equality",
 857                     "==".to_string(),
 858                     applicability,
 859                 );
 860             }
 861
 862             if self.sess().if_let_suggestions.borrow().get(&expr.span).is_some() {
 863                 // We already emitted an `if let` suggestion due to an identifier not found.
 864                 err.delay_as_bug();
 865             } else {
 866                 err.emit();
 867             }
 868             return self.tcx.ty_error();
 869         }
 870
 871         self.check_lhs_assignable(lhs, "E0070", span);
 872
 873         let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
 874         let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty, Some(lhs));
 875
 876         self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
 877
 878         if lhs_ty.references_error() || rhs_ty.references_error() {
 879             self.tcx.ty_error()
 880         } else {
 881             self.tcx.mk_unit()
 882         }
 883     }
 884
 885     fn check_expr_loop(
 886         &self,
 887         body: &'tcx hir::Block<'tcx>,
 888         source: hir::LoopSource,
 889         expected: Expectation<'tcx>,
 890         expr: &'tcx hir::Expr<'tcx>,
 891     ) -> Ty<'tcx> {
 892         let coerce = match source {
 893             // you can only use break with a value from a normal `loop { }`
 894             hir::LoopSource::Loop => {
 895                 let coerce_to = expected.coercion_target_type(self, body.span);
 896                 Some(CoerceMany::new(coerce_to))
 897             }
 898
 899             hir::LoopSource::While | hir::LoopSource::WhileLet | hir::LoopSource::ForLoop => None,
 900         };
 901
 902         let ctxt = BreakableCtxt {
 903             coerce,
 904             may_break: false, // Will get updated if/when we find a `break`.
 905         };
 906
 907         let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
 908             self.check_block_no_value(&body);
 909         });
 910
 911         if ctxt.may_break {
 912             // No way to know whether it's diverging because
 913             // of a `break` or an outer `break` or `return`.
 914             self.diverges.set(Diverges::Maybe);
 915         }
 916
 917         // If we permit break with a value, then result type is
 918         // the LUB of the breaks (possibly ! if none); else, it
 919         // is nil. This makes sense because infinite loops
 920         // (which would have type !) are only possible iff we
 921         // permit break with a value [1].
 922         if ctxt.coerce.is_none() && !ctxt.may_break {
 923             // [1]
 924             self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
 925         }
 926         ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
 927     }
 928
 929     /// Checks a method call.
 930     fn check_method_call(
 931         &self,
 932         expr: &'tcx hir::Expr<'tcx>,
 933         segment: &hir::PathSegment<'_>,
 934         span: Span,
 935         args: &'tcx [hir::Expr<'tcx>],
 936         expected: Expectation<'tcx>,
 937     ) -> Ty<'tcx> {
 938         let rcvr = &args[0];
 939         let rcvr_t = self.check_expr(&rcvr);
 940         // no need to check for bot/err -- callee does that
 941         let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
 942
 943         let method = match self.lookup_method(rcvr_t, segment, span, expr, rcvr) {
 944             Ok(method) => {
 945                 // We could add a "consider `foo::<params>`" suggestion here, but I wasn't able to
 946                 // trigger this codepath causing `structuraly_resolved_type` to emit an error.
 947
 948                 self.write_method_call(expr.hir_id, method);
 949                 Ok(method)
 950             }
 951             Err(error) => {
 952                 if segment.ident.name != kw::Empty {
 953                     if let Some(mut err) = self.report_method_error(
 954                         span,
 955                         rcvr_t,
 956                         segment.ident,
 957                         SelfSource::MethodCall(&args[0]),
 958                         error,
 959                         Some(args),
 960                     ) {
 961                         err.emit();
 962                     }
 963                 }
 964                 Err(())
 965             }
 966         };
 967
 968         // Call the generic checker.
 969         self.check_method_argument_types(
 970             span,
 971             expr,
 972             method,
 973             &args[1..],
 974             DontTupleArguments,
 975             expected,
 976         )
 977     }
 978
 979     fn check_expr_cast(
 980         &self,
 981         e: &'tcx hir::Expr<'tcx>,
 982         t: &'tcx hir::Ty<'tcx>,
 983         expr: &'tcx hir::Expr<'tcx>,
 984     ) -> Ty<'tcx> {
 985         // Find the type of `e`. Supply hints based on the type we are casting to,
 986         // if appropriate.
 987         let t_cast = self.to_ty_saving_user_provided_ty(t);
 988         let t_cast = self.resolve_vars_if_possible(t_cast);
 989         let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
 990         let t_cast = self.resolve_vars_if_possible(t_cast);
 991
 992         // Eagerly check for some obvious errors.
 993         if t_expr.references_error() || t_cast.references_error() {
 994             self.tcx.ty_error()
 995         } else {
 996             // Defer other checks until we're done type checking.
 997             let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
 998             match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
 999                 Ok(cast_check) => {
1000                     deferred_cast_checks.push(cast_check);
1001                     t_cast
1002                 }
1003                 Err(ErrorReported) => self.tcx.ty_error(),
1004             }
1005         }
1006     }
1007
1008     fn check_expr_array(
1009         &self,
1010         args: &'tcx [hir::Expr<'tcx>],
1011         expected: Expectation<'tcx>,
1012         expr: &'tcx hir::Expr<'tcx>,
1013     ) -> Ty<'tcx> {
1014         let element_ty = if !args.is_empty() {
1015             let coerce_to = expected
1016                 .to_option(self)
1017                 .and_then(|uty| match *uty.kind() {
1018                     ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
1019                     _ => None,
1020                 })
1021                 .unwrap_or_else(|| {
1022                     self.next_ty_var(TypeVariableOrigin {
1023                         kind: TypeVariableOriginKind::TypeInference,
1024                         span: expr.span,
1025                     })
1026                 });
1027             let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
1028             assert_eq!(self.diverges.get(), Diverges::Maybe);
1029             for e in args {
1030                 let e_ty = self.check_expr_with_hint(e, coerce_to);
1031                 let cause = self.misc(e.span);
1032                 coerce.coerce(self, &cause, e, e_ty);
1033             }
1034             coerce.complete(self)
1035         } else {
1036             self.next_ty_var(TypeVariableOrigin {
1037                 kind: TypeVariableOriginKind::TypeInference,
1038                 span: expr.span,
1039             })
1040         };
1041         self.tcx.mk_array(element_ty, args.len() as u64)
1042     }
1043
1044     fn check_expr_repeat(
1045         &self,
1046         element: &'tcx hir::Expr<'tcx>,
1047         count: &'tcx hir::AnonConst,
1048         expected: Expectation<'tcx>,
1049         _expr: &'tcx hir::Expr<'tcx>,
1050     ) -> Ty<'tcx> {
1051         let tcx = self.tcx;
1052         let count = self.to_const(count);
1053
1054         let uty = match expected {
1055             ExpectHasType(uty) => match *uty.kind() {
1056                 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
1057                 _ => None,
1058             },
1059             _ => None,
1060         };
1061
1062         let (element_ty, t) = match uty {
1063             Some(uty) => {
1064                 self.check_expr_coercable_to_type(&element, uty, None);
1065                 (uty, uty)
1066             }
1067             None => {
1068                 let ty = self.next_ty_var(TypeVariableOrigin {
1069                     kind: TypeVariableOriginKind::MiscVariable,
1070                     span: element.span,
1071                 });
1072                 let element_ty = self.check_expr_has_type_or_error(&element, ty, |_| {});
1073                 (element_ty, ty)
1074             }
1075         };
1076
1077         if element_ty.references_error() {
1078             return tcx.ty_error();
1079         }
1080
1081         tcx.mk_ty(ty::Array(t, count))
1082     }
1083
1084     fn check_expr_tuple(
1085         &self,
1086         elts: &'tcx [hir::Expr<'tcx>],
1087         expected: Expectation<'tcx>,
1088         expr: &'tcx hir::Expr<'tcx>,
1089     ) -> Ty<'tcx> {
1090         let flds = expected.only_has_type(self).and_then(|ty| {
1091             let ty = self.resolve_vars_with_obligations(ty);
1092             match ty.kind() {
1093                 ty::Tuple(flds) => Some(&flds[..]),
1094                 _ => None,
1095             }
1096         });
1097
1098         let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| match flds {
1099             Some(fs) if i < fs.len() => {
1100                 let ety = fs[i].expect_ty();
1101                 self.check_expr_coercable_to_type(&e, ety, None);
1102                 ety
1103             }
1104             _ => self.check_expr_with_expectation(&e, NoExpectation),
1105         });
1106         let tuple = self.tcx.mk_tup(elt_ts_iter);
1107         if tuple.references_error() {
1108             self.tcx.ty_error()
1109         } else {
1110             self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
1111             tuple
1112         }
1113     }
1114
1115     fn check_expr_struct(
1116         &self,
1117         expr: &hir::Expr<'_>,
1118         expected: Expectation<'tcx>,
1119         qpath: &QPath<'_>,
1120         fields: &'tcx [hir::ExprField<'tcx>],
1121         base_expr: &'tcx Option<&'tcx hir::Expr<'tcx>>,
1122     ) -> Ty<'tcx> {
1123         // Find the relevant variant
1124         let (variant, adt_ty) = if let Some(variant_ty) = self.check_struct_path(qpath, expr.hir_id)
1125         {
1126             variant_ty
1127         } else {
1128             self.check_struct_fields_on_error(fields, base_expr);
1129             return self.tcx.ty_error();
1130         };
1131
1132         // Prohibit struct expressions when non-exhaustive flag is set.
1133         let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
1134         if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
1135             self.tcx
1136                 .sess
1137                 .emit_err(StructExprNonExhaustive { span: expr.span, what: adt.variant_descr() });
1138         }
1139
1140         let error_happened = self.check_expr_struct_fields(
1141             adt_ty,
1142             expected,
1143             expr.hir_id,
1144             qpath.span(),
1145             variant,
1146             fields,
1147             base_expr.is_none(),
1148         );
1149         if let Some(base_expr) = base_expr {
1150             // If check_expr_struct_fields hit an error, do not attempt to populate
1151             // the fields with the base_expr. This could cause us to hit errors later
1152             // when certain fields are assumed to exist that in fact do not.
1153             if !error_happened {
1154                 self.check_expr_has_type_or_error(base_expr, adt_ty, |_| {});
1155                 match adt_ty.kind() {
1156                     ty::Adt(adt, substs) if adt.is_struct() => {
1157                         let fru_field_types = adt
1158                             .non_enum_variant()
1159                             .fields
1160                             .iter()
1161                             .map(|f| {
1162                                 self.normalize_associated_types_in(
1163                                     expr.span,
1164                                     f.ty(self.tcx, substs),
1165                                 )
1166                             })
1167                             .collect();
1168
1169                         self.typeck_results
1170                             .borrow_mut()
1171                             .fru_field_types_mut()
1172                             .insert(expr.hir_id, fru_field_types);
1173                     }
1174                     _ => {
1175                         self.tcx
1176                             .sess
1177                             .emit_err(FunctionalRecordUpdateOnNonStruct { span: base_expr.span });
1178                     }
1179                 }
1180             }
1181         }
1182         self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
1183         adt_ty
1184     }
1185
1186     fn check_expr_struct_fields(
1187         &self,
1188         adt_ty: Ty<'tcx>,
1189         expected: Expectation<'tcx>,
1190         expr_id: hir::HirId,
1191         span: Span,
1192         variant: &'tcx ty::VariantDef,
1193         ast_fields: &'tcx [hir::ExprField<'tcx>],
1194         check_completeness: bool,
1195     ) -> bool {
1196         let tcx = self.tcx;
1197
1198         let adt_ty_hint = self
1199             .expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
1200             .get(0)
1201             .cloned()
1202             .unwrap_or(adt_ty);
1203         // re-link the regions that EIfEO can erase.
1204         self.demand_eqtype(span, adt_ty_hint, adt_ty);
1205
1206         let (substs, adt_kind, kind_name) = match adt_ty.kind() {
1207             ty::Adt(adt, substs) => (substs, adt.adt_kind(), adt.variant_descr()),
1208             _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields"),
1209         };
1210
1211         let mut remaining_fields = variant
1212             .fields
1213             .iter()
1214             .enumerate()
1215             .map(|(i, field)| (field.ident.normalize_to_macros_2_0(), (i, field)))
1216             .collect::<FxHashMap<_, _>>();
1217
1218         let mut seen_fields = FxHashMap::default();
1219
1220         let mut error_happened = false;
1221
1222         // Type-check each field.
1223         for field in ast_fields {
1224             let ident = tcx.adjust_ident(field.ident, variant.def_id);
1225             let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
1226                 seen_fields.insert(ident, field.span);
1227                 self.write_field_index(field.hir_id, i);
1228
1229                 // We don't look at stability attributes on
1230                 // struct-like enums (yet...), but it's definitely not
1231                 // a bug to have constructed one.
1232                 if adt_kind != AdtKind::Enum {
1233                     tcx.check_stability(v_field.did, Some(expr_id), field.span);
1234                 }
1235
1236                 self.field_ty(field.span, v_field, substs)
1237             } else {
1238                 error_happened = true;
1239                 if let Some(prev_span) = seen_fields.get(&ident) {
1240                     tcx.sess.emit_err(FieldMultiplySpecifiedInInitializer {
1241                         span: field.ident.span,
1242                         prev_span: *prev_span,
1243                         ident,
1244                     });
1245                 } else {
1246                     self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name, span);
1247                 }
1248
1249                 tcx.ty_error()
1250             };
1251
1252             // Make sure to give a type to the field even if there's
1253             // an error, so we can continue type-checking.
1254             self.check_expr_coercable_to_type(&field.expr, field_type, None);
1255         }
1256
1257         // Make sure the programmer specified correct number of fields.
1258         if kind_name == "union" {
1259             if ast_fields.len() != 1 {
1260                 tcx.sess.span_err(span, "union expressions should have exactly one field");
1261             }
1262         } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
1263             let no_accessible_remaining_fields = remaining_fields
1264                 .iter()
1265                 .find(|(_, (_, field))| {
1266                     field.vis.is_accessible_from(tcx.parent_module(expr_id).to_def_id(), tcx)
1267                 })
1268                 .is_none();
1269
1270             if no_accessible_remaining_fields {
1271                 self.report_no_accessible_fields(adt_ty, span);
1272             } else {
1273                 self.report_missing_fields(adt_ty, span, remaining_fields);
1274             }
1275         }
1276
1277         error_happened
1278     }
1279
1280     fn check_struct_fields_on_error(
1281         &self,
1282         fields: &'tcx [hir::ExprField<'tcx>],
1283         base_expr: &'tcx Option<&'tcx hir::Expr<'tcx>>,
1284     ) {
1285         for field in fields {
1286             self.check_expr(&field.expr);
1287         }
1288         if let Some(base) = *base_expr {
1289             self.check_expr(&base);
1290         }
1291     }
1292
1293     /// Report an error for a struct field expression when there are fields which aren't provided.
1294     ///
1295     /// ```text
1296     /// error: missing field `you_can_use_this_field` in initializer of `foo::Foo`
1297     ///  --> src/main.rs:8:5
1298     ///   |
1299     /// 8 |     foo::Foo {};
1300     ///   |     ^^^^^^^^ missing `you_can_use_this_field`
1301     ///
1302     /// error: aborting due to previous error
1303     /// ```
1304     fn report_missing_fields(
1305         &self,
1306         adt_ty: Ty<'tcx>,
1307         span: Span,
1308         remaining_fields: FxHashMap<Ident, (usize, &ty::FieldDef)>,
1309     ) {
1310         let len = remaining_fields.len();
1311
1312         let mut displayable_field_names =
1313             remaining_fields.keys().map(|ident| ident.as_str()).collect::<Vec<_>>();
1314
1315         displayable_field_names.sort();
1316
1317         let mut truncated_fields_error = String::new();
1318         let remaining_fields_names = match &displayable_field_names[..] {
1319             [field1] => format!("`{}`", field1),
1320             [field1, field2] => format!("`{}` and `{}`", field1, field2),
1321             [field1, field2, field3] => format!("`{}`, `{}` and `{}`", field1, field2, field3),
1322             _ => {
1323                 truncated_fields_error =
1324                     format!(" and {} other field{}", len - 3, pluralize!(len - 3));
1325                 displayable_field_names
1326                     .iter()
1327                     .take(3)
1328                     .map(|n| format!("`{}`", n))
1329                     .collect::<Vec<_>>()
1330                     .join(", ")
1331             }
1332         };
1333
1334         struct_span_err!(
1335             self.tcx.sess,
1336             span,
1337             E0063,
1338             "missing field{} {}{} in initializer of `{}`",
1339             pluralize!(len),
1340             remaining_fields_names,
1341             truncated_fields_error,
1342             adt_ty
1343         )
1344         .span_label(span, format!("missing {}{}", remaining_fields_names, truncated_fields_error))
1345         .emit();
1346     }
1347
1348     /// Report an error for a struct field expression when there are no visible fields.
1349     ///
1350     /// ```text
1351     /// error: cannot construct `Foo` with struct literal syntax due to inaccessible fields
1352     ///  --> src/main.rs:8:5
1353     ///   |
1354     /// 8 |     foo::Foo {};
1355     ///   |     ^^^^^^^^
1356     ///
1357     /// error: aborting due to previous error
1358     /// ```
1359     fn report_no_accessible_fields(&self, adt_ty: Ty<'tcx>, span: Span) {
1360         self.tcx.sess.span_err(
1361             span,
1362             &format!(
1363                 "cannot construct `{}` with struct literal syntax due to inaccessible fields",
1364                 adt_ty,
1365             ),
1366         );
1367     }
1368
1369     fn report_unknown_field(
1370         &self,
1371         ty: Ty<'tcx>,
1372         variant: &'tcx ty::VariantDef,
1373         field: &hir::ExprField<'_>,
1374         skip_fields: &[hir::ExprField<'_>],
1375         kind_name: &str,
1376         ty_span: Span,
1377     ) {
1378         if variant.is_recovered() {
1379             self.set_tainted_by_errors();
1380             return;
1381         }
1382         let mut err = self.type_error_struct_with_diag(
1383             field.ident.span,
1384             |actual| match ty.kind() {
1385                 ty::Adt(adt, ..) if adt.is_enum() => struct_span_err!(
1386                     self.tcx.sess,
1387                     field.ident.span,
1388                     E0559,
1389                     "{} `{}::{}` has no field named `{}`",
1390                     kind_name,
1391                     actual,
1392                     variant.ident,
1393                     field.ident
1394                 ),
1395                 _ => struct_span_err!(
1396                     self.tcx.sess,
1397                     field.ident.span,
1398                     E0560,
1399                     "{} `{}` has no field named `{}`",
1400                     kind_name,
1401                     actual,
1402                     field.ident
1403                 ),
1404             },
1405             ty,
1406         );
1407         match variant.ctor_kind {
1408             CtorKind::Fn => match ty.kind() {
1409                 ty::Adt(adt, ..) if adt.is_enum() => {
1410                     err.span_label(
1411                         variant.ident.span,
1412                         format!(
1413                             "`{adt}::{variant}` defined here",
1414                             adt = ty,
1415                             variant = variant.ident,
1416                         ),
1417                     );
1418                     err.span_label(field.ident.span, "field does not exist");
1419                     err.span_suggestion(
1420                         ty_span,
1421                         &format!(
1422                             "`{adt}::{variant}` is a tuple {kind_name}, use the appropriate syntax",
1423                             adt = ty,
1424                             variant = variant.ident,
1425                         ),
1426                         format!(
1427                             "{adt}::{variant}(/* fields */)",
1428                             adt = ty,
1429                             variant = variant.ident,
1430                         ),
1431                         Applicability::HasPlaceholders,
1432                     );
1433                 }
1434                 _ => {
1435                     err.span_label(variant.ident.span, format!("`{adt}` defined here", adt = ty));
1436                     err.span_label(field.ident.span, "field does not exist");
1437                     err.span_suggestion(
1438                         ty_span,
1439                         &format!(
1440                             "`{adt}` is a tuple {kind_name}, use the appropriate syntax",
1441                             adt = ty,
1442                             kind_name = kind_name,
1443                         ),
1444                         format!("{adt}(/* fields */)", adt = ty),
1445                         Applicability::HasPlaceholders,
1446                     );
1447                 }
1448             },
1449             _ => {
1450                 // prevent all specified fields from being suggested
1451                 let skip_fields = skip_fields.iter().map(|x| x.ident.name);
1452                 if let Some(field_name) =
1453                     Self::suggest_field_name(variant, field.ident.name, skip_fields.collect())
1454                 {
1455                     err.span_suggestion(
1456                         field.ident.span,
1457                         "a field with a similar name exists",
1458                         field_name.to_string(),
1459                         Applicability::MaybeIncorrect,
1460                     );
1461                 } else {
1462                     match ty.kind() {
1463                         ty::Adt(adt, ..) => {
1464                             if adt.is_enum() {
1465                                 err.span_label(
1466                                     field.ident.span,
1467                                     format!("`{}::{}` does not have this field", ty, variant.ident),
1468                                 );
1469                             } else {
1470                                 err.span_label(
1471                                     field.ident.span,
1472                                     format!("`{}` does not have this field", ty),
1473                                 );
1474                             }
1475                             let available_field_names = self.available_field_names(variant);
1476                             if !available_field_names.is_empty() {
1477                                 err.note(&format!(
1478                                     "available fields are: {}",
1479                                     self.name_series_display(available_field_names)
1480                                 ));
1481                             }
1482                         }
1483                         _ => bug!("non-ADT passed to report_unknown_field"),
1484                     }
1485                 };
1486             }
1487         }
1488         err.emit();
1489     }
1490
1491     // Return an hint about the closest match in field names
1492     fn suggest_field_name(
1493         variant: &'tcx ty::VariantDef,
1494         field: Symbol,
1495         skip: Vec<Symbol>,
1496     ) -> Option<Symbol> {
1497         let names = variant
1498             .fields
1499             .iter()
1500             .filter_map(|field| {
1501                 // ignore already set fields and private fields from non-local crates
1502                 if skip.iter().any(|&x| x == field.ident.name)
1503                     || (!variant.def_id.is_local() && field.vis != Visibility::Public)
1504                 {
1505                     None
1506                 } else {
1507                     Some(field.ident.name)
1508                 }
1509             })
1510             .collect::<Vec<Symbol>>();
1511
1512         find_best_match_for_name(&names, field, None)
1513     }
1514
1515     fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<Symbol> {
1516         variant
1517             .fields
1518             .iter()
1519             .filter(|field| {
1520                 let def_scope = self
1521                     .tcx
1522                     .adjust_ident_and_get_scope(field.ident, variant.def_id, self.body_id)
1523                     .1;
1524                 field.vis.is_accessible_from(def_scope, self.tcx)
1525             })
1526             .map(|field| field.ident.name)
1527             .collect()
1528     }
1529
1530     fn name_series_display(&self, names: Vec<Symbol>) -> String {
1531         // dynamic limit, to never omit just one field
1532         let limit = if names.len() == 6 { 6 } else { 5 };
1533         let mut display =
1534             names.iter().take(limit).map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
1535         if names.len() > limit {
1536             display = format!("{} ... and {} others", display, names.len() - limit);
1537         }
1538         display
1539     }
1540
1541     // Check field access expressions
1542     fn check_field(
1543         &self,
1544         expr: &'tcx hir::Expr<'tcx>,
1545         base: &'tcx hir::Expr<'tcx>,
1546         field: Ident,
1547     ) -> Ty<'tcx> {
1548         debug!("check_field(expr: {:?}, base: {:?}, field: {:?})", expr, base, field);
1549         let expr_t = self.check_expr(base);
1550         let expr_t = self.structurally_resolved_type(base.span, expr_t);
1551         let mut private_candidate = None;
1552         let mut autoderef = self.autoderef(expr.span, expr_t);
1553         while let Some((base_t, _)) = autoderef.next() {
1554             debug!("base_t: {:?}", base_t);
1555             match base_t.kind() {
1556                 ty::Adt(base_def, substs) if !base_def.is_enum() => {
1557                     debug!("struct named {:?}", base_t);
1558                     let (ident, def_scope) =
1559                         self.tcx.adjust_ident_and_get_scope(field, base_def.did, self.body_id);
1560                     let fields = &base_def.non_enum_variant().fields;
1561                     if let Some(index) =
1562                         fields.iter().position(|f| f.ident.normalize_to_macros_2_0() == ident)
1563                     {
1564                         let field = &fields[index];
1565                         let field_ty = self.field_ty(expr.span, field, substs);
1566                         // Save the index of all fields regardless of their visibility in case
1567                         // of error recovery.
1568                         self.write_field_index(expr.hir_id, index);
1569                         if field.vis.is_accessible_from(def_scope, self.tcx) {
1570                             let adjustments = self.adjust_steps(&autoderef);
1571                             self.apply_adjustments(base, adjustments);
1572                             self.register_predicates(autoderef.into_obligations());
1573
1574                             self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span);
1575                             return field_ty;
1576                         }
1577                         private_candidate = Some((base_def.did, field_ty));
1578                     }
1579                 }
1580                 ty::Tuple(tys) => {
1581                     let fstr = field.as_str();
1582                     if let Ok(index) = fstr.parse::<usize>() {
1583                         if fstr == index.to_string() {
1584                             if let Some(field_ty) = tys.get(index) {
1585                                 let adjustments = self.adjust_steps(&autoderef);
1586                                 self.apply_adjustments(base, adjustments);
1587                                 self.register_predicates(autoderef.into_obligations());
1588
1589                                 self.write_field_index(expr.hir_id, index);
1590                                 return field_ty.expect_ty();
1591                             }
1592                         }
1593                     }
1594                 }
1595                 _ => {}
1596             }
1597         }
1598         self.structurally_resolved_type(autoderef.span(), autoderef.final_ty(false));
1599
1600         if let Some((did, field_ty)) = private_candidate {
1601             self.ban_private_field_access(expr, expr_t, field, did);
1602             return field_ty;
1603         }
1604
1605         if field.name == kw::Empty {
1606         } else if self.method_exists(field, expr_t, expr.hir_id, true) {
1607             self.ban_take_value_of_method(expr, expr_t, field);
1608         } else if !expr_t.is_primitive_ty() {
1609             self.ban_nonexisting_field(field, base, expr, expr_t);
1610         } else {
1611             type_error_struct!(
1612                 self.tcx().sess,
1613                 field.span,
1614                 expr_t,
1615                 E0610,
1616                 "`{}` is a primitive type and therefore doesn't have fields",
1617                 expr_t
1618             )
1619             .emit();
1620         }
1621
1622         self.tcx().ty_error()
1623     }
1624
1625     fn suggest_await_on_field_access(
1626         &self,
1627         err: &mut DiagnosticBuilder<'_>,
1628         field_ident: Ident,
1629         base: &'tcx hir::Expr<'tcx>,
1630         ty: Ty<'tcx>,
1631     ) {
1632         let output_ty = match self.infcx.get_impl_future_output_ty(ty) {
1633             Some(output_ty) => self.resolve_vars_if_possible(output_ty),
1634             _ => return,
1635         };
1636         let mut add_label = true;
1637         if let ty::Adt(def, _) = output_ty.kind() {
1638             // no field access on enum type
1639             if !def.is_enum() {
1640                 if def.non_enum_variant().fields.iter().any(|field| field.ident == field_ident) {
1641                     add_label = false;
1642                     err.span_label(
1643                         field_ident.span,
1644                         "field not available in `impl Future`, but it is available in its `Output`",
1645                     );
1646                     err.span_suggestion_verbose(
1647                         base.span.shrink_to_hi(),
1648                         "consider `await`ing on the `Future` and access the field of its `Output`",
1649                         ".await".to_string(),
1650                         Applicability::MaybeIncorrect,
1651                     );
1652                 }
1653             }
1654         }
1655         if add_label {
1656             err.span_label(field_ident.span, &format!("field not found in `{}`", ty));
1657         }
1658     }
1659
1660     fn ban_nonexisting_field(
1661         &self,
1662         field: Ident,
1663         base: &'tcx hir::Expr<'tcx>,
1664         expr: &'tcx hir::Expr<'tcx>,
1665         expr_t: Ty<'tcx>,
1666     ) {
1667         debug!(
1668             "ban_nonexisting_field: field={:?}, base={:?}, expr={:?}, expr_ty={:?}",
1669             field, base, expr, expr_t
1670         );
1671         let mut err = self.no_such_field_err(field, expr_t);
1672
1673         match *expr_t.peel_refs().kind() {
1674             ty::Array(_, len) => {
1675                 self.maybe_suggest_array_indexing(&mut err, expr, base, field, len);
1676             }
1677             ty::RawPtr(..) => {
1678                 self.suggest_first_deref_field(&mut err, expr, base, field);
1679             }
1680             ty::Adt(def, _) if !def.is_enum() => {
1681                 self.suggest_fields_on_recordish(&mut err, def, field);
1682             }
1683             ty::Param(param_ty) => {
1684                 self.point_at_param_definition(&mut err, param_ty);
1685             }
1686             ty::Opaque(_, _) => {
1687                 self.suggest_await_on_field_access(&mut err, field, base, expr_t.peel_refs());
1688             }
1689             _ => {}
1690         }
1691
1692         if field.name == kw::Await {
1693             // We know by construction that `<expr>.await` is either on Rust 2015
1694             // or results in `ExprKind::Await`. Suggest switching the edition to 2018.
1695             err.note("to `.await` a `Future`, switch to Rust 2018 or later");
1696             err.help(&format!("set `edition = \"{}\"` in `Cargo.toml`", LATEST_STABLE_EDITION));
1697             err.note("for more on editions, read https://doc.rust-lang.org/edition-guide");
1698         }
1699
1700         err.emit();
1701     }
1702
1703     fn ban_private_field_access(
1704         &self,
1705         expr: &hir::Expr<'_>,
1706         expr_t: Ty<'tcx>,
1707         field: Ident,
1708         base_did: DefId,
1709     ) {
1710         let struct_path = self.tcx().def_path_str(base_did);
1711         let kind_name = self.tcx().def_kind(base_did).descr(base_did);
1712         let mut err = struct_span_err!(
1713             self.tcx().sess,
1714             field.span,
1715             E0616,
1716             "field `{}` of {} `{}` is private",
1717             field,
1718             kind_name,
1719             struct_path
1720         );
1721         err.span_label(field.span, "private field");
1722         // Also check if an accessible method exists, which is often what is meant.
1723         if self.method_exists(field, expr_t, expr.hir_id, false) && !self.expr_in_place(expr.hir_id)
1724         {
1725             self.suggest_method_call(
1726                 &mut err,
1727                 &format!("a method `{}` also exists, call it with parentheses", field),
1728                 field,
1729                 expr_t,
1730                 expr,
1731             );
1732         }
1733         err.emit();
1734     }
1735
1736     fn ban_take_value_of_method(&self, expr: &hir::Expr<'_>, expr_t: Ty<'tcx>, field: Ident) {
1737         let mut err = type_error_struct!(
1738             self.tcx().sess,
1739             field.span,
1740             expr_t,
1741             E0615,
1742             "attempted to take value of method `{}` on type `{}`",
1743             field,
1744             expr_t
1745         );
1746         err.span_label(field.span, "method, not a field");
1747         if !self.expr_in_place(expr.hir_id) {
1748             self.suggest_method_call(
1749                 &mut err,
1750                 "use parentheses to call the method",
1751                 field,
1752                 expr_t,
1753                 expr,
1754             );
1755         } else {
1756             err.help("methods are immutable and cannot be assigned to");
1757         }
1758
1759         err.emit();
1760     }
1761
1762     fn point_at_param_definition(&self, err: &mut DiagnosticBuilder<'_>, param: ty::ParamTy) {
1763         let generics = self.tcx.generics_of(self.body_id.owner.to_def_id());
1764         let generic_param = generics.type_param(&param, self.tcx);
1765         if let ty::GenericParamDefKind::Type { synthetic: Some(..), .. } = generic_param.kind {
1766             return;
1767         }
1768         let param_def_id = generic_param.def_id;
1769         let param_hir_id = match param_def_id.as_local() {
1770             Some(x) => self.tcx.hir().local_def_id_to_hir_id(x),
1771             None => return,
1772         };
1773         let param_span = self.tcx.hir().span(param_hir_id);
1774         let param_name = self.tcx.hir().ty_param_name(param_hir_id);
1775
1776         err.span_label(param_span, &format!("type parameter '{}' declared here", param_name));
1777     }
1778
1779     fn suggest_fields_on_recordish(
1780         &self,
1781         err: &mut DiagnosticBuilder<'_>,
1782         def: &'tcx ty::AdtDef,
1783         field: Ident,
1784     ) {
1785         if let Some(suggested_field_name) =
1786             Self::suggest_field_name(def.non_enum_variant(), field.name, vec![])
1787         {
1788             err.span_suggestion(
1789                 field.span,
1790                 "a field with a similar name exists",
1791                 suggested_field_name.to_string(),
1792                 Applicability::MaybeIncorrect,
1793             );
1794         } else {
1795             err.span_label(field.span, "unknown field");
1796             let struct_variant_def = def.non_enum_variant();
1797             let field_names = self.available_field_names(struct_variant_def);
1798             if !field_names.is_empty() {
1799                 err.note(&format!(
1800                     "available fields are: {}",
1801                     self.name_series_display(field_names),
1802                 ));
1803             }
1804         }
1805     }
1806
1807     fn maybe_suggest_array_indexing(
1808         &self,
1809         err: &mut DiagnosticBuilder<'_>,
1810         expr: &hir::Expr<'_>,
1811         base: &hir::Expr<'_>,
1812         field: Ident,
1813         len: &ty::Const<'tcx>,
1814     ) {
1815         if let (Some(len), Ok(user_index)) =
1816             (len.try_eval_usize(self.tcx, self.param_env), field.as_str().parse::<u64>())
1817         {
1818             if let Ok(base) = self.tcx.sess.source_map().span_to_snippet(base.span) {
1819                 let help = "instead of using tuple indexing, use array indexing";
1820                 let suggestion = format!("{}[{}]", base, field);
1821                 let applicability = if len < user_index {
1822                     Applicability::MachineApplicable
1823                 } else {
1824                     Applicability::MaybeIncorrect
1825                 };
1826                 err.span_suggestion(expr.span, help, suggestion, applicability);
1827             }
1828         }
1829     }
1830
1831     fn suggest_first_deref_field(
1832         &self,
1833         err: &mut DiagnosticBuilder<'_>,
1834         expr: &hir::Expr<'_>,
1835         base: &hir::Expr<'_>,
1836         field: Ident,
1837     ) {
1838         if let Ok(base) = self.tcx.sess.source_map().span_to_snippet(base.span) {
1839             let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
1840             let suggestion = format!("(*{}).{}", base, field);
1841             err.span_suggestion(expr.span, &msg, suggestion, Applicability::MaybeIncorrect);
1842         }
1843     }
1844
1845     fn no_such_field_err(
1846         &self,
1847         field: Ident,
1848         expr_t: &'tcx ty::TyS<'tcx>,
1849     ) -> DiagnosticBuilder<'_> {
1850         let span = field.span;
1851         debug!("no_such_field_err(span: {:?}, field: {:?}, expr_t: {:?})", span, field, expr_t);
1852
1853         let mut err = type_error_struct!(
1854             self.tcx().sess,
1855             field.span,
1856             expr_t,
1857             E0609,
1858             "no field `{}` on type `{}`",
1859             field,
1860             expr_t
1861         );
1862
1863         // try to add a suggestion in case the field is a nested field of a field of the Adt
1864         if let Some((fields, substs)) = self.get_field_candidates(span, &expr_t) {
1865             for candidate_field in fields.iter() {
1866                 if let Some(field_path) =
1867                     self.check_for_nested_field(span, field, candidate_field, substs, vec![])
1868                 {
1869                     let field_path_str = field_path
1870                         .iter()
1871                         .map(|id| id.name.to_ident_string())
1872                         .collect::<Vec<String>>()
1873                         .join(".");
1874                     debug!("field_path_str: {:?}", field_path_str);
1875
1876                     err.span_suggestion_verbose(
1877                         field.span.shrink_to_lo(),
1878                         "one of the expressions' fields has a field of the same name",
1879                         format!("{}.", field_path_str),
1880                         Applicability::MaybeIncorrect,
1881                     );
1882                 }
1883             }
1884         }
1885         err
1886     }
1887
1888     fn get_field_candidates(
1889         &self,
1890         span: Span,
1891         base_t: Ty<'tcx>,
1892     ) -> Option<(&Vec<ty::FieldDef>, SubstsRef<'tcx>)> {
1893         debug!("get_field_candidates(span: {:?}, base_t: {:?}", span, base_t);
1894
1895         let mut autoderef = self.autoderef(span, base_t);
1896         while let Some((base_t, _)) = autoderef.next() {
1897             match base_t.kind() {
1898                 ty::Adt(base_def, substs) if !base_def.is_enum() => {
1899                     let fields = &base_def.non_enum_variant().fields;
1900                     // For compile-time reasons put a limit on number of fields we search
1901                     if fields.len() > 100 {
1902                         return None;
1903                     }
1904                     return Some((fields, substs));
1905                 }
1906                 _ => {}
1907             }
1908         }
1909         None
1910     }
1911
1912     /// This method is called after we have encountered a missing field error to recursively
1913     /// search for the field
1914     fn check_for_nested_field(
1915         &self,
1916         span: Span,
1917         target_field: Ident,
1918         candidate_field: &ty::FieldDef,
1919         subst: SubstsRef<'tcx>,
1920         mut field_path: Vec<Ident>,
1921     ) -> Option<Vec<Ident>> {
1922         debug!(
1923             "check_for_nested_field(span: {:?}, candidate_field: {:?}, field_path: {:?}",
1924             span, candidate_field, field_path
1925         );
1926
1927         if candidate_field.ident == target_field {
1928             Some(field_path)
1929         } else if field_path.len() > 3 {
1930             // For compile-time reasons and to avoid infinite recursion we only check for fields
1931             // up to a depth of three
1932             None
1933         } else {
1934             // recursively search fields of `candidate_field` if it's a ty::Adt
1935
1936             field_path.push(candidate_field.ident.normalize_to_macros_2_0());
1937             let field_ty = candidate_field.ty(self.tcx, subst);
1938             if let Some((nested_fields, subst)) = self.get_field_candidates(span, &field_ty) {
1939                 for field in nested_fields.iter() {
1940                     let ident = field.ident.normalize_to_macros_2_0();
1941                     if ident == target_field {
1942                         return Some(field_path);
1943                     } else {
1944                         let field_path = field_path.clone();
1945                         if let Some(path) = self.check_for_nested_field(
1946                             span,
1947                             target_field,
1948                             field,
1949                             subst,
1950                             field_path,
1951                         ) {
1952                             return Some(path);
1953                         }
1954                     }
1955                 }
1956             }
1957             None
1958         }
1959     }
1960
1961     fn check_expr_index(
1962         &self,
1963         base: &'tcx hir::Expr<'tcx>,
1964         idx: &'tcx hir::Expr<'tcx>,
1965         expr: &'tcx hir::Expr<'tcx>,
1966     ) -> Ty<'tcx> {
1967         let base_t = self.check_expr(&base);
1968         let idx_t = self.check_expr(&idx);
1969
1970         if base_t.references_error() {
1971             base_t
1972         } else if idx_t.references_error() {
1973             idx_t
1974         } else {
1975             let base_t = self.structurally_resolved_type(base.span, base_t);
1976             match self.lookup_indexing(expr, base, base_t, idx_t) {
1977                 Some((index_ty, element_ty)) => {
1978                     // two-phase not needed because index_ty is never mutable
1979                     self.demand_coerce(idx, idx_t, index_ty, None, AllowTwoPhase::No);
1980                     element_ty
1981                 }
1982                 None => {
1983                     let mut err = type_error_struct!(
1984                         self.tcx.sess,
1985                         expr.span,
1986                         base_t,
1987                         E0608,
1988                         "cannot index into a value of type `{}`",
1989                         base_t
1990                     );
1991                     // Try to give some advice about indexing tuples.
1992                     if let ty::Tuple(..) = base_t.kind() {
1993                         let mut needs_note = true;
1994                         // If the index is an integer, we can show the actual
1995                         // fixed expression:
1996                         if let ExprKind::Lit(ref lit) = idx.kind {
1997                             if let ast::LitKind::Int(i, ast::LitIntType::Unsuffixed) = lit.node {
1998                                 let snip = self.tcx.sess.source_map().span_to_snippet(base.span);
1999                                 if let Ok(snip) = snip {
2000                                     err.span_suggestion(
2001                                         expr.span,
2002                                         "to access tuple elements, use",
2003                                         format!("{}.{}", snip, i),
2004                                         Applicability::MachineApplicable,
2005                                     );
2006                                     needs_note = false;
2007                                 }
2008                             }
2009                         }
2010                         if needs_note {
2011                             err.help(
2012                                 "to access tuple elements, use tuple indexing \
2013                                         syntax (e.g., `tuple.0`)",
2014                             );
2015                         }
2016                     }
2017                     err.emit();
2018                     self.tcx.ty_error()
2019                 }
2020             }
2021         }
2022     }
2023
2024     fn check_expr_yield(
2025         &self,
2026         value: &'tcx hir::Expr<'tcx>,
2027         expr: &'tcx hir::Expr<'tcx>,
2028         src: &'tcx hir::YieldSource,
2029     ) -> Ty<'tcx> {
2030         match self.resume_yield_tys {
2031             Some((resume_ty, yield_ty)) => {
2032                 self.check_expr_coercable_to_type(&value, yield_ty, None);
2033
2034                 resume_ty
2035             }
2036             // Given that this `yield` expression was generated as a result of lowering a `.await`,
2037             // we know that the yield type must be `()`; however, the context won't contain this
2038             // information. Hence, we check the source of the yield expression here and check its
2039             // value's type against `()` (this check should always hold).
2040             None if src.is_await() => {
2041                 self.check_expr_coercable_to_type(&value, self.tcx.mk_unit(), None);
2042                 self.tcx.mk_unit()
2043             }
2044             _ => {
2045                 self.tcx.sess.emit_err(YieldExprOutsideOfGenerator { span: expr.span });
2046                 // Avoid expressions without types during writeback (#78653).
2047                 self.check_expr(value);
2048                 self.tcx.mk_unit()
2049             }
2050         }
2051     }
2052
2053     fn check_expr_asm_operand(&self, expr: &'tcx hir::Expr<'tcx>, is_input: bool) {
2054         let needs = if is_input { Needs::None } else { Needs::MutPlace };
2055         let ty = self.check_expr_with_needs(expr, needs);
2056         self.require_type_is_sized(ty, expr.span, traits::InlineAsmSized);
2057
2058         if !is_input && !expr.is_syntactic_place_expr() {
2059             let mut err = self.tcx.sess.struct_span_err(expr.span, "invalid asm output");
2060             err.span_label(expr.span, "cannot assign to this expression");
2061             err.emit();
2062         }
2063
2064         // If this is an input value, we require its type to be fully resolved
2065         // at this point. This allows us to provide helpful coercions which help
2066         // pass the type candidate list in a later pass.
2067         //
2068         // We don't require output types to be resolved at this point, which
2069         // allows them to be inferred based on how they are used later in the
2070         // function.
2071         if is_input {
2072             let ty = self.structurally_resolved_type(expr.span, &ty);
2073             match *ty.kind() {
2074                 ty::FnDef(..) => {
2075                     let fnptr_ty = self.tcx.mk_fn_ptr(ty.fn_sig(self.tcx));
2076                     self.demand_coerce(expr, ty, fnptr_ty, None, AllowTwoPhase::No);
2077                 }
2078                 ty::Ref(_, base_ty, mutbl) => {
2079                     let ptr_ty = self.tcx.mk_ptr(ty::TypeAndMut { ty: base_ty, mutbl });
2080                     self.demand_coerce(expr, ty, ptr_ty, None, AllowTwoPhase::No);
2081                 }
2082                 _ => {}
2083             }
2084         }
2085     }
2086
2087     fn check_expr_asm(&self, asm: &'tcx hir::InlineAsm<'tcx>) -> Ty<'tcx> {
2088         for (op, _op_sp) in asm.operands {
2089             match op {
2090                 hir::InlineAsmOperand::In { expr, .. } | hir::InlineAsmOperand::Const { expr } => {
2091                     self.check_expr_asm_operand(expr, true);
2092                 }
2093                 hir::InlineAsmOperand::Out { expr, .. } => {
2094                     if let Some(expr) = expr {
2095                         self.check_expr_asm_operand(expr, false);
2096                     }
2097                 }
2098                 hir::InlineAsmOperand::InOut { expr, .. } => {
2099                     self.check_expr_asm_operand(expr, false);
2100                 }
2101                 hir::InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
2102                     self.check_expr_asm_operand(in_expr, true);
2103                     if let Some(out_expr) = out_expr {
2104                         self.check_expr_asm_operand(out_expr, false);
2105                     }
2106                 }
2107                 hir::InlineAsmOperand::Sym { expr } => {
2108                     self.check_expr(expr);
2109                 }
2110             }
2111         }
2112         if asm.options.contains(ast::InlineAsmOptions::NORETURN) {
2113             self.tcx.types.never
2114         } else {
2115             self.tcx.mk_unit()
2116         }
2117     }
2118 }
2119
2120 pub(super) fn ty_kind_suggestion(ty: Ty<'_>) -> Option<&'static str> {
2121     Some(match ty.kind() {
2122         ty::Bool => "true",
2123         ty::Char => "'a'",
2124         ty::Int(_) | ty::Uint(_) => "42",
2125         ty::Float(_) => "3.14159",
2126         ty::Error(_) | ty::Never => return None,
2127         _ => "value",
2128     })
2129 }