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