compiler/rustc_hir_typeck/src/expr.rs

   1 //! Type checking expressions.
   2 //!
   3 //! See `mod.rs` for more context on type checking in general.
   4
   5 use crate::cast;
   6 use crate::coercion::CoerceMany;
   7 use crate::coercion::DynamicCoerceMany;
   8 use crate::errors::{AddressOfTemporaryTaken, ReturnStmtOutsideOfFnBody, StructExprNonExhaustive};
   9 use crate::errors::{
  10     FieldMultiplySpecifiedInInitializer, FunctionalRecordUpdateOnNonStruct,
  11     YieldExprOutsideOfGenerator,
  12 };
  13 use crate::fatally_break_rust;
  14 use crate::method::SelfSource;
  15 use crate::type_error_struct;
  16 use crate::Expectation::{self, ExpectCastableToType, ExpectHasType, NoExpectation};
  17 use crate::{
  18     report_unexpected_variant_res, BreakableCtxt, Diverges, FnCtxt, Needs,
  19     TupleArgumentsFlag::DontTupleArguments,
  20 };
  21 use rustc_ast as ast;
  22 use rustc_data_structures::fx::FxHashMap;
  23 use rustc_data_structures::stack::ensure_sufficient_stack;
  24 use rustc_errors::{
  25     pluralize, struct_span_err, Applicability, Diagnostic, DiagnosticBuilder, DiagnosticId,
  26     ErrorGuaranteed, StashKey,
  27 };
  28 use rustc_hir as hir;
  29 use rustc_hir::def::{CtorKind, DefKind, Res};
  30 use rustc_hir::def_id::DefId;
  31 use rustc_hir::intravisit::Visitor;
  32 use rustc_hir::lang_items::LangItem;
  33 use rustc_hir::{Closure, ExprKind, HirId, QPath};
  34 use rustc_hir_analysis::astconv::AstConv as _;
  35 use rustc_hir_analysis::check::ty_kind_suggestion;
  36 use rustc_infer::infer;
  37 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
  38 use rustc_infer::infer::InferOk;
  39 use rustc_infer::traits::ObligationCause;
  40 use rustc_middle::middle::stability;
  41 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase};
  42 use rustc_middle::ty::error::TypeError::FieldMisMatch;
  43 use rustc_middle::ty::subst::SubstsRef;
  44 use rustc_middle::ty::{self, AdtKind, Ty, TypeVisitable};
  45 use rustc_session::errors::ExprParenthesesNeeded;
  46 use rustc_session::parse::feature_err;
  47 use rustc_span::hygiene::DesugaringKind;
  48 use rustc_span::lev_distance::find_best_match_for_name;
  49 use rustc_span::source_map::{Span, Spanned};
  50 use rustc_span::symbol::{kw, sym, Ident, Symbol};
  51 use rustc_target::spec::abi::Abi::RustIntrinsic;
  52 use rustc_trait_selection::infer::InferCtxtExt;
  53 use rustc_trait_selection::traits::{self, ObligationCauseCode};
  54
  55 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  56     fn check_expr_eq_type(&self, expr: &'tcx hir::Expr<'tcx>, expected: Ty<'tcx>) {
  57         let ty = self.check_expr_with_hint(expr, expected);
  58         self.demand_eqtype(expr.span, expected, ty);
  59     }
  60
  61     pub fn check_expr_has_type_or_error(
  62         &self,
  63         expr: &'tcx hir::Expr<'tcx>,
  64         expected: Ty<'tcx>,
  65         extend_err: impl FnMut(&mut Diagnostic),
  66     ) -> Ty<'tcx> {
  67         self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected), extend_err)
  68     }
  69
  70     fn check_expr_meets_expectation_or_error(
  71         &self,
  72         expr: &'tcx hir::Expr<'tcx>,
  73         expected: Expectation<'tcx>,
  74         mut extend_err: impl FnMut(&mut Diagnostic),
  75     ) -> Ty<'tcx> {
  76         let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
  77         let mut ty = self.check_expr_with_expectation(expr, expected);
  78
  79         // While we don't allow *arbitrary* coercions here, we *do* allow
  80         // coercions from ! to `expected`.
  81         if ty.is_never() {
  82             if let Some(adjustments) = self.typeck_results.borrow().adjustments().get(expr.hir_id) {
  83                 let reported = self.tcx().sess.delay_span_bug(
  84                     expr.span,
  85                     "expression with never type wound up being adjusted",
  86                 );
  87                 return if let [Adjustment { kind: Adjust::NeverToAny, target }] = &adjustments[..] {
  88                     target.to_owned()
  89                 } else {
  90                     self.tcx().ty_error_with_guaranteed(reported)
  91                 };
  92             }
  93
  94             let adj_ty = self.next_ty_var(TypeVariableOrigin {
  95                 kind: TypeVariableOriginKind::AdjustmentType,
  96                 span: expr.span,
  97             });
  98             self.apply_adjustments(
  99                 expr,
 100                 vec![Adjustment { kind: Adjust::NeverToAny, target: adj_ty }],
 101             );
 102             ty = adj_ty;
 103         }
 104
 105         if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
 106             let expr = expr.peel_drop_temps();
 107             self.suggest_deref_ref_or_into(&mut err, expr, expected_ty, ty, None);
 108             extend_err(&mut err);
 109             err.emit();
 110         }
 111         ty
 112     }
 113
 114     pub(super) fn check_expr_coercable_to_type(
 115         &self,
 116         expr: &'tcx hir::Expr<'tcx>,
 117         expected: Ty<'tcx>,
 118         expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
 119     ) -> Ty<'tcx> {
 120         let ty = self.check_expr_with_hint(expr, expected);
 121         // checks don't need two phase
 122         self.demand_coerce(expr, ty, expected, expected_ty_expr, AllowTwoPhase::No)
 123     }
 124
 125     pub(super) fn check_expr_with_hint(
 126         &self,
 127         expr: &'tcx hir::Expr<'tcx>,
 128         expected: Ty<'tcx>,
 129     ) -> Ty<'tcx> {
 130         self.check_expr_with_expectation(expr, ExpectHasType(expected))
 131     }
 132
 133     fn check_expr_with_expectation_and_needs(
 134         &self,
 135         expr: &'tcx hir::Expr<'tcx>,
 136         expected: Expectation<'tcx>,
 137         needs: Needs,
 138     ) -> Ty<'tcx> {
 139         let ty = self.check_expr_with_expectation(expr, expected);
 140
 141         // If the expression is used in a place whether mutable place is required
 142         // e.g. LHS of assignment, perform the conversion.
 143         if let Needs::MutPlace = needs {
 144             self.convert_place_derefs_to_mutable(expr);
 145         }
 146
 147         ty
 148     }
 149
 150     pub(super) fn check_expr(&self, expr: &'tcx hir::Expr<'tcx>) -> Ty<'tcx> {
 151         self.check_expr_with_expectation(expr, NoExpectation)
 152     }
 153
 154     pub(super) fn check_expr_with_needs(
 155         &self,
 156         expr: &'tcx hir::Expr<'tcx>,
 157         needs: Needs,
 158     ) -> Ty<'tcx> {
 159         self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
 160     }
 161
 162     /// Invariant:
 163     /// If an expression has any sub-expressions that result in a type error,
 164     /// inspecting that expression's type with `ty.references_error()` will return
 165     /// true. Likewise, if an expression is known to diverge, inspecting its
 166     /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
 167     /// strict, _|_ can appear in the type of an expression that does not,
 168     /// itself, diverge: for example, fn() -> _|_.)
 169     /// Note that inspecting a type's structure *directly* may expose the fact
 170     /// that there are actually multiple representations for `Error`, so avoid
 171     /// that when err needs to be handled differently.
 172     #[instrument(skip(self, expr), level = "debug")]
 173     pub(super) fn check_expr_with_expectation(
 174         &self,
 175         expr: &'tcx hir::Expr<'tcx>,
 176         expected: Expectation<'tcx>,
 177     ) -> Ty<'tcx> {
 178         self.check_expr_with_expectation_and_args(expr, expected, &[])
 179     }
 180
 181     /// Same as `check_expr_with_expectation`, but allows us to pass in the arguments of a
 182     /// `ExprKind::Call` when evaluating its callee when it is an `ExprKind::Path`.
 183     pub(super) fn check_expr_with_expectation_and_args(
 184         &self,
 185         expr: &'tcx hir::Expr<'tcx>,
 186         expected: Expectation<'tcx>,
 187         args: &'tcx [hir::Expr<'tcx>],
 188     ) -> Ty<'tcx> {
 189         if self.tcx().sess.verbose() {
 190             // make this code only run with -Zverbose because it is probably slow
 191             if let Ok(lint_str) = self.tcx.sess.source_map().span_to_snippet(expr.span) {
 192                 if !lint_str.contains('\n') {
 193                     debug!("expr text: {lint_str}");
 194                 } else {
 195                     let mut lines = lint_str.lines();
 196                     if let Some(line0) = lines.next() {
 197                         let remaining_lines = lines.count();
 198                         debug!("expr text: {line0}");
 199                         debug!("expr text: ...(and {remaining_lines} more lines)");
 200                     }
 201                 }
 202             }
 203         }
 204
 205         // True if `expr` is a `Try::from_ok(())` that is a result of desugaring a try block
 206         // without the final expr (e.g. `try { return; }`). We don't want to generate an
 207         // unreachable_code lint for it since warnings for autogenerated code are confusing.
 208         let is_try_block_generated_unit_expr = match expr.kind {
 209             ExprKind::Call(_, args) if expr.span.is_desugaring(DesugaringKind::TryBlock) => {
 210                 args.len() == 1 && args[0].span.is_desugaring(DesugaringKind::TryBlock)
 211             }
 212
 213             _ => false,
 214         };
 215
 216         // Warn for expressions after diverging siblings.
 217         if !is_try_block_generated_unit_expr {
 218             self.warn_if_unreachable(expr.hir_id, expr.span, "expression");
 219         }
 220
 221         // Hide the outer diverging and has_errors flags.
 222         let old_diverges = self.diverges.replace(Diverges::Maybe);
 223
 224         let ty = ensure_sufficient_stack(|| match &expr.kind {
 225             hir::ExprKind::Path(
 226                 qpath @ hir::QPath::Resolved(..) | qpath @ hir::QPath::TypeRelative(..),
 227             ) => self.check_expr_path(qpath, expr, args),
 228             _ => self.check_expr_kind(expr, expected),
 229         });
 230
 231         // Warn for non-block expressions with diverging children.
 232         match expr.kind {
 233             ExprKind::Block(..)
 234             | ExprKind::If(..)
 235             | ExprKind::Let(..)
 236             | ExprKind::Loop(..)
 237             | ExprKind::Match(..) => {}
 238             // If `expr` is a result of desugaring the try block and is an ok-wrapped
 239             // diverging expression (e.g. it arose from desugaring of `try { return }`),
 240             // we skip issuing a warning because it is autogenerated code.
 241             ExprKind::Call(..) if expr.span.is_desugaring(DesugaringKind::TryBlock) => {}
 242             ExprKind::Call(callee, _) => self.warn_if_unreachable(expr.hir_id, callee.span, "call"),
 243             ExprKind::MethodCall(segment, ..) => {
 244                 self.warn_if_unreachable(expr.hir_id, segment.ident.span, "call")
 245             }
 246             _ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression"),
 247         }
 248
 249         // Any expression that produces a value of type `!` must have diverged
 250         if ty.is_never() {
 251             self.diverges.set(self.diverges.get() | Diverges::always(expr.span));
 252         }
 253
 254         // Record the type, which applies it effects.
 255         // We need to do this after the warning above, so that
 256         // we don't warn for the diverging expression itself.
 257         self.write_ty(expr.hir_id, ty);
 258
 259         // Combine the diverging and has_error flags.
 260         self.diverges.set(self.diverges.get() | old_diverges);
 261
 262         debug!("type of {} is...", self.tcx.hir().node_to_string(expr.hir_id));
 263         debug!("... {:?}, expected is {:?}", ty, expected);
 264
 265         ty
 266     }
 267
 268     #[instrument(skip(self, expr), level = "debug")]
 269     fn check_expr_kind(
 270         &self,
 271         expr: &'tcx hir::Expr<'tcx>,
 272         expected: Expectation<'tcx>,
 273     ) -> Ty<'tcx> {
 274         trace!("expr={:#?}", expr);
 275
 276         let tcx = self.tcx;
 277         match expr.kind {
 278             ExprKind::Box(subexpr) => self.check_expr_box(subexpr, expected),
 279             ExprKind::Lit(ref lit) => self.check_lit(&lit, expected),
 280             ExprKind::Binary(op, lhs, rhs) => self.check_binop(expr, op, lhs, rhs, expected),
 281             ExprKind::Assign(lhs, rhs, span) => {
 282                 self.check_expr_assign(expr, expected, lhs, rhs, span)
 283             }
 284             ExprKind::AssignOp(op, lhs, rhs) => {
 285                 self.check_binop_assign(expr, op, lhs, rhs, expected)
 286             }
 287             ExprKind::Unary(unop, oprnd) => self.check_expr_unary(unop, oprnd, expected, expr),
 288             ExprKind::AddrOf(kind, mutbl, oprnd) => {
 289                 self.check_expr_addr_of(kind, mutbl, oprnd, expected, expr)
 290             }
 291             ExprKind::Path(QPath::LangItem(lang_item, _, hir_id)) => {
 292                 self.check_lang_item_path(lang_item, expr, hir_id)
 293             }
 294             ExprKind::Path(ref qpath) => self.check_expr_path(qpath, expr, &[]),
 295             ExprKind::InlineAsm(asm) => {
 296                 // We defer some asm checks as we may not have resolved the input and output types yet (they may still be infer vars).
 297                 self.deferred_asm_checks.borrow_mut().push((asm, expr.hir_id));
 298                 self.check_expr_asm(asm)
 299             }
 300             ExprKind::Break(destination, ref expr_opt) => {
 301                 self.check_expr_break(destination, expr_opt.as_deref(), expr)
 302             }
 303             ExprKind::Continue(destination) => {
 304                 if destination.target_id.is_ok() {
 305                     tcx.types.never
 306                 } else {
 307                     // There was an error; make type-check fail.
 308                     tcx.ty_error()
 309                 }
 310             }
 311             ExprKind::Ret(ref expr_opt) => self.check_expr_return(expr_opt.as_deref(), expr),
 312             ExprKind::Let(let_expr) => self.check_expr_let(let_expr),
 313             ExprKind::Loop(body, _, source, _) => {
 314                 self.check_expr_loop(body, source, expected, expr)
 315             }
 316             ExprKind::Match(discrim, arms, match_src) => {
 317                 self.check_match(expr, &discrim, arms, expected, match_src)
 318             }
 319             ExprKind::Closure(&Closure { capture_clause, fn_decl, body, movability, .. }) => {
 320                 self.check_expr_closure(expr, capture_clause, &fn_decl, body, movability, expected)
 321             }
 322             ExprKind::Block(body, _) => self.check_block_with_expected(&body, expected),
 323             ExprKind::Call(callee, args) => self.check_call(expr, &callee, args, expected),
 324             ExprKind::MethodCall(segment, receiver, args, _) => {
 325                 self.check_method_call(expr, segment, receiver, args, expected)
 326             }
 327             ExprKind::Cast(e, t) => self.check_expr_cast(e, t, expr),
 328             ExprKind::Type(e, t) => {
 329                 let ty = self.to_ty_saving_user_provided_ty(&t);
 330                 self.check_expr_eq_type(&e, ty);
 331                 ty
 332             }
 333             ExprKind::If(cond, then_expr, opt_else_expr) => {
 334                 self.check_then_else(cond, then_expr, opt_else_expr, expr.span, expected)
 335             }
 336             ExprKind::DropTemps(e) => self.check_expr_with_expectation(e, expected),
 337             ExprKind::Array(args) => self.check_expr_array(args, expected, expr),
 338             ExprKind::ConstBlock(ref anon_const) => {
 339                 self.check_expr_const_block(anon_const, expected, expr)
 340             }
 341             ExprKind::Repeat(element, ref count) => {
 342                 self.check_expr_repeat(element, count, expected, expr)
 343             }
 344             ExprKind::Tup(elts) => self.check_expr_tuple(elts, expected, expr),
 345             ExprKind::Struct(qpath, fields, ref base_expr) => {
 346                 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
 347             }
 348             ExprKind::Field(base, field) => self.check_field(expr, &base, field),
 349             ExprKind::Index(base, idx) => self.check_expr_index(base, idx, expr),
 350             ExprKind::Yield(value, ref src) => self.check_expr_yield(value, expr, src),
 351             hir::ExprKind::Err => tcx.ty_error(),
 352         }
 353     }
 354
 355     fn check_expr_box(&self, expr: &'tcx hir::Expr<'tcx>, expected: Expectation<'tcx>) -> Ty<'tcx> {
 356         let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| match ty.kind() {
 357             ty::Adt(def, _) if def.is_box() => Expectation::rvalue_hint(self, ty.boxed_ty()),
 358             _ => NoExpectation,
 359         });
 360         let referent_ty = self.check_expr_with_expectation(expr, expected_inner);
 361         self.require_type_is_sized(referent_ty, expr.span, traits::SizedBoxType);
 362         self.tcx.mk_box(referent_ty)
 363     }
 364
 365     fn check_expr_unary(
 366         &self,
 367         unop: hir::UnOp,
 368         oprnd: &'tcx hir::Expr<'tcx>,
 369         expected: Expectation<'tcx>,
 370         expr: &'tcx hir::Expr<'tcx>,
 371     ) -> Ty<'tcx> {
 372         let tcx = self.tcx;
 373         let expected_inner = match unop {
 374             hir::UnOp::Not | hir::UnOp::Neg => expected,
 375             hir::UnOp::Deref => NoExpectation,
 376         };
 377         let mut oprnd_t = self.check_expr_with_expectation(&oprnd, expected_inner);
 378
 379         if !oprnd_t.references_error() {
 380             oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
 381             match unop {
 382                 hir::UnOp::Deref => {
 383                     if let Some(ty) = self.lookup_derefing(expr, oprnd, oprnd_t) {
 384                         oprnd_t = ty;
 385                     } else {
 386                         let mut err = type_error_struct!(
 387                             tcx.sess,
 388                             expr.span,
 389                             oprnd_t,
 390                             E0614,
 391                             "type `{oprnd_t}` cannot be dereferenced",
 392                         );
 393                         let sp = tcx.sess.source_map().start_point(expr.span);
 394                         if let Some(sp) =
 395                             tcx.sess.parse_sess.ambiguous_block_expr_parse.borrow().get(&sp)
 396                         {
 397                             err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp));
 398                         }
 399                         oprnd_t = tcx.ty_error_with_guaranteed(err.emit());
 400                     }
 401                 }
 402                 hir::UnOp::Not => {
 403                     let result = self.check_user_unop(expr, oprnd_t, unop, expected_inner);
 404                     // If it's builtin, we can reuse the type, this helps inference.
 405                     if !(oprnd_t.is_integral() || *oprnd_t.kind() == ty::Bool) {
 406                         oprnd_t = result;
 407                     }
 408                 }
 409                 hir::UnOp::Neg => {
 410                     let result = self.check_user_unop(expr, oprnd_t, unop, expected_inner);
 411                     // If it's builtin, we can reuse the type, this helps inference.
 412                     if !oprnd_t.is_numeric() {
 413                         oprnd_t = result;
 414                     }
 415                 }
 416             }
 417         }
 418         oprnd_t
 419     }
 420
 421     fn check_expr_addr_of(
 422         &self,
 423         kind: hir::BorrowKind,
 424         mutbl: hir::Mutability,
 425         oprnd: &'tcx hir::Expr<'tcx>,
 426         expected: Expectation<'tcx>,
 427         expr: &'tcx hir::Expr<'tcx>,
 428     ) -> Ty<'tcx> {
 429         let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
 430             match ty.kind() {
 431                 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
 432                     if oprnd.is_syntactic_place_expr() {
 433                         // Places may legitimately have unsized types.
 434                         // For example, dereferences of a fat pointer and
 435                         // the last field of a struct can be unsized.
 436                         ExpectHasType(*ty)
 437                     } else {
 438                         Expectation::rvalue_hint(self, *ty)
 439                     }
 440                 }
 441                 _ => NoExpectation,
 442             }
 443         });
 444         let ty =
 445             self.check_expr_with_expectation_and_needs(&oprnd, hint, Needs::maybe_mut_place(mutbl));
 446
 447         let tm = ty::TypeAndMut { ty, mutbl };
 448         match kind {
 449             _ if tm.ty.references_error() => self.tcx.ty_error(),
 450             hir::BorrowKind::Raw => {
 451                 self.check_named_place_expr(oprnd);
 452                 self.tcx.mk_ptr(tm)
 453             }
 454             hir::BorrowKind::Ref => {
 455                 // Note: at this point, we cannot say what the best lifetime
 456                 // is to use for resulting pointer.  We want to use the
 457                 // shortest lifetime possible so as to avoid spurious borrowck
 458                 // errors.  Moreover, the longest lifetime will depend on the
 459                 // precise details of the value whose address is being taken
 460                 // (and how long it is valid), which we don't know yet until
 461                 // type inference is complete.
 462                 //
 463                 // Therefore, here we simply generate a region variable. The
 464                 // region inferencer will then select a suitable value.
 465                 // Finally, borrowck will infer the value of the region again,
 466                 // this time with enough precision to check that the value
 467                 // whose address was taken can actually be made to live as long
 468                 // as it needs to live.
 469                 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
 470                 self.tcx.mk_ref(region, tm)
 471             }
 472         }
 473     }
 474
 475     /// Does this expression refer to a place that either:
 476     /// * Is based on a local or static.
 477     /// * Contains a dereference
 478     /// Note that the adjustments for the children of `expr` should already
 479     /// have been resolved.
 480     fn check_named_place_expr(&self, oprnd: &'tcx hir::Expr<'tcx>) {
 481         let is_named = oprnd.is_place_expr(|base| {
 482             // Allow raw borrows if there are any deref adjustments.
 483             //
 484             // const VAL: (i32,) = (0,);
 485             // const REF: &(i32,) = &(0,);
 486             //
 487             // &raw const VAL.0;            // ERROR
 488             // &raw const REF.0;            // OK, same as &raw const (*REF).0;
 489             //
 490             // This is maybe too permissive, since it allows
 491             // `let u = &raw const Box::new((1,)).0`, which creates an
 492             // immediately dangling raw pointer.
 493             self.typeck_results
 494                 .borrow()
 495                 .adjustments()
 496                 .get(base.hir_id)
 497                 .map_or(false, |x| x.iter().any(|adj| matches!(adj.kind, Adjust::Deref(_))))
 498         });
 499         if !is_named {
 500             self.tcx.sess.emit_err(AddressOfTemporaryTaken { span: oprnd.span });
 501         }
 502     }
 503
 504     fn check_lang_item_path(
 505         &self,
 506         lang_item: hir::LangItem,
 507         expr: &'tcx hir::Expr<'tcx>,
 508         hir_id: Option<hir::HirId>,
 509     ) -> Ty<'tcx> {
 510         self.resolve_lang_item_path(lang_item, expr.span, expr.hir_id, hir_id).1
 511     }
 512
 513     pub(crate) fn check_expr_path(
 514         &self,
 515         qpath: &'tcx hir::QPath<'tcx>,
 516         expr: &'tcx hir::Expr<'tcx>,
 517         args: &'tcx [hir::Expr<'tcx>],
 518     ) -> Ty<'tcx> {
 519         let tcx = self.tcx;
 520         let (res, opt_ty, segs) =
 521             self.resolve_ty_and_res_fully_qualified_call(qpath, expr.hir_id, expr.span);
 522         let ty = match res {
 523             Res::Err => {
 524                 self.set_tainted_by_errors();
 525                 tcx.ty_error()
 526             }
 527             Res::Def(DefKind::Ctor(_, CtorKind::Fictive), _) => {
 528                 report_unexpected_variant_res(tcx, res, qpath, expr.span);
 529                 tcx.ty_error()
 530             }
 531             _ => self.instantiate_value_path(segs, opt_ty, res, expr.span, expr.hir_id).0,
 532         };
 533
 534         if let ty::FnDef(did, ..) = *ty.kind() {
 535             let fn_sig = ty.fn_sig(tcx);
 536             if tcx.fn_sig(did).abi() == RustIntrinsic && tcx.item_name(did) == sym::transmute {
 537                 let from = fn_sig.inputs().skip_binder()[0];
 538                 let to = fn_sig.output().skip_binder();
 539                 // We defer the transmute to the end of typeck, once all inference vars have
 540                 // been resolved or we errored. This is important as we can only check transmute
 541                 // on concrete types, but the output type may not be known yet (it would only
 542                 // be known if explicitly specified via turbofish).
 543                 self.deferred_transmute_checks.borrow_mut().push((from, to, expr.hir_id));
 544             }
 545             if !tcx.features().unsized_fn_params {
 546                 // We want to remove some Sized bounds from std functions,
 547                 // but don't want to expose the removal to stable Rust.
 548                 // i.e., we don't want to allow
 549                 //
 550                 // ```rust
 551                 // drop as fn(str);
 552                 // ```
 553                 //
 554                 // to work in stable even if the Sized bound on `drop` is relaxed.
 555                 for i in 0..fn_sig.inputs().skip_binder().len() {
 556                     // We just want to check sizedness, so instead of introducing
 557                     // placeholder lifetimes with probing, we just replace higher lifetimes
 558                     // with fresh vars.
 559                     let span = args.get(i).map(|a| a.span).unwrap_or(expr.span);
 560                     let input = self.replace_bound_vars_with_fresh_vars(
 561                         span,
 562                         infer::LateBoundRegionConversionTime::FnCall,
 563                         fn_sig.input(i),
 564                     );
 565                     self.require_type_is_sized_deferred(
 566                         input,
 567                         span,
 568                         traits::SizedArgumentType(None),
 569                     );
 570                 }
 571             }
 572             // Here we want to prevent struct constructors from returning unsized types.
 573             // There were two cases this happened: fn pointer coercion in stable
 574             // and usual function call in presence of unsized_locals.
 575             // Also, as we just want to check sizedness, instead of introducing
 576             // placeholder lifetimes with probing, we just replace higher lifetimes
 577             // with fresh vars.
 578             let output = self.replace_bound_vars_with_fresh_vars(
 579                 expr.span,
 580                 infer::LateBoundRegionConversionTime::FnCall,
 581                 fn_sig.output(),
 582             );
 583             self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
 584         }
 585
 586         // We always require that the type provided as the value for
 587         // a type parameter outlives the moment of instantiation.
 588         let substs = self.typeck_results.borrow().node_substs(expr.hir_id);
 589         self.add_wf_bounds(substs, expr);
 590
 591         ty
 592     }
 593
 594     fn check_expr_break(
 595         &self,
 596         destination: hir::Destination,
 597         expr_opt: Option<&'tcx hir::Expr<'tcx>>,
 598         expr: &'tcx hir::Expr<'tcx>,
 599     ) -> Ty<'tcx> {
 600         let tcx = self.tcx;
 601         if let Ok(target_id) = destination.target_id {
 602             let (e_ty, cause);
 603             if let Some(e) = expr_opt {
 604                 // If this is a break with a value, we need to type-check
 605                 // the expression. Get an expected type from the loop context.
 606                 let opt_coerce_to = {
 607                     // We should release `enclosing_breakables` before the `check_expr_with_hint`
 608                     // below, so can't move this block of code to the enclosing scope and share
 609                     // `ctxt` with the second `enclosing_breakables` borrow below.
 610                     let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
 611                     match enclosing_breakables.opt_find_breakable(target_id) {
 612                         Some(ctxt) => ctxt.coerce.as_ref().map(|coerce| coerce.expected_ty()),
 613                         None => {
 614                             // Avoid ICE when `break` is inside a closure (#65383).
 615                             return tcx.ty_error_with_message(
 616                                 expr.span,
 617                                 "break was outside loop, but no error was emitted",
 618                             );
 619                         }
 620                     }
 621                 };
 622
 623                 // If the loop context is not a `loop { }`, then break with
 624                 // a value is illegal, and `opt_coerce_to` will be `None`.
 625                 // Just set expectation to error in that case.
 626                 let coerce_to = opt_coerce_to.unwrap_or_else(|| tcx.ty_error());
 627
 628                 // Recurse without `enclosing_breakables` borrowed.
 629                 e_ty = self.check_expr_with_hint(e, coerce_to);
 630                 cause = self.misc(e.span);
 631             } else {
 632                 // Otherwise, this is a break *without* a value. That's
 633                 // always legal, and is equivalent to `break ()`.
 634                 e_ty = tcx.mk_unit();
 635                 cause = self.misc(expr.span);
 636             }
 637
 638             // Now that we have type-checked `expr_opt`, borrow
 639             // the `enclosing_loops` field and let's coerce the
 640             // type of `expr_opt` into what is expected.
 641             let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
 642             let Some(ctxt) = enclosing_breakables.opt_find_breakable(target_id) else {
 643                 // Avoid ICE when `break` is inside a closure (#65383).
 644                 return tcx.ty_error_with_message(
 645                     expr.span,
 646                     "break was outside loop, but no error was emitted",
 647                 );
 648             };
 649
 650             if let Some(ref mut coerce) = ctxt.coerce {
 651                 if let Some(ref e) = expr_opt {
 652                     coerce.coerce(self, &cause, e, e_ty);
 653                 } else {
 654                     assert!(e_ty.is_unit());
 655                     let ty = coerce.expected_ty();
 656                     coerce.coerce_forced_unit(
 657                         self,
 658                         &cause,
 659                         &mut |mut err| {
 660                             self.suggest_mismatched_types_on_tail(
 661                                 &mut err, expr, ty, e_ty, target_id,
 662                             );
 663                             if let Some(val) = ty_kind_suggestion(ty) {
 664                                 let label = destination
 665                                     .label
 666                                     .map(|l| format!(" {}", l.ident))
 667                                     .unwrap_or_else(String::new);
 668                                 err.span_suggestion(
 669                                     expr.span,
 670                                     "give it a value of the expected type",
 671                                     format!("break{label} {val}"),
 672                                     Applicability::HasPlaceholders,
 673                                 );
 674                             }
 675                         },
 676                         false,
 677                     );
 678                 }
 679             } else {
 680                 // If `ctxt.coerce` is `None`, we can just ignore
 681                 // the type of the expression.  This is because
 682                 // either this was a break *without* a value, in
 683                 // which case it is always a legal type (`()`), or
 684                 // else an error would have been flagged by the
 685                 // `loops` pass for using break with an expression
 686                 // where you are not supposed to.
 687                 assert!(expr_opt.is_none() || self.tcx.sess.has_errors().is_some());
 688             }
 689
 690             // If we encountered a `break`, then (no surprise) it may be possible to break from the
 691             // loop... unless the value being returned from the loop diverges itself, e.g.
 692             // `break return 5` or `break loop {}`.
 693             ctxt.may_break |= !self.diverges.get().is_always();
 694
 695             // the type of a `break` is always `!`, since it diverges
 696             tcx.types.never
 697         } else {
 698             // Otherwise, we failed to find the enclosing loop;
 699             // this can only happen if the `break` was not
 700             // inside a loop at all, which is caught by the
 701             // loop-checking pass.
 702             let err = self.tcx.ty_error_with_message(
 703                 expr.span,
 704                 "break was outside loop, but no error was emitted",
 705             );
 706
 707             // We still need to assign a type to the inner expression to
 708             // prevent the ICE in #43162.
 709             if let Some(e) = expr_opt {
 710                 self.check_expr_with_hint(e, err);
 711
 712                 // ... except when we try to 'break rust;'.
 713                 // ICE this expression in particular (see #43162).
 714                 if let ExprKind::Path(QPath::Resolved(_, path)) = e.kind {
 715                     if path.segments.len() == 1 && path.segments[0].ident.name == sym::rust {
 716                         fatally_break_rust(self.tcx.sess);
 717                     }
 718                 }
 719             }
 720
 721             // There was an error; make type-check fail.
 722             err
 723         }
 724     }
 725
 726     fn check_expr_return(
 727         &self,
 728         expr_opt: Option<&'tcx hir::Expr<'tcx>>,
 729         expr: &'tcx hir::Expr<'tcx>,
 730     ) -> Ty<'tcx> {
 731         if self.ret_coercion.is_none() {
 732             let mut err = ReturnStmtOutsideOfFnBody {
 733                 span: expr.span,
 734                 encl_body_span: None,
 735                 encl_fn_span: None,
 736             };
 737
 738             let encl_item_id = self.tcx.hir().get_parent_item(expr.hir_id);
 739
 740             if let Some(hir::Node::Item(hir::Item {
 741                 kind: hir::ItemKind::Fn(..),
 742                 span: encl_fn_span,
 743                 ..
 744             }))
 745             | Some(hir::Node::TraitItem(hir::TraitItem {
 746                 kind: hir::TraitItemKind::Fn(_, hir::TraitFn::Provided(_)),
 747                 span: encl_fn_span,
 748                 ..
 749             }))
 750             | Some(hir::Node::ImplItem(hir::ImplItem {
 751                 kind: hir::ImplItemKind::Fn(..),
 752                 span: encl_fn_span,
 753                 ..
 754             })) = self.tcx.hir().find_by_def_id(encl_item_id.def_id)
 755             {
 756                 // We are inside a function body, so reporting "return statement
 757                 // outside of function body" needs an explanation.
 758
 759                 let encl_body_owner_id = self.tcx.hir().enclosing_body_owner(expr.hir_id);
 760
 761                 // If this didn't hold, we would not have to report an error in
 762                 // the first place.
 763                 assert_ne!(encl_item_id.def_id, encl_body_owner_id);
 764
 765                 let encl_body_id = self.tcx.hir().body_owned_by(encl_body_owner_id);
 766                 let encl_body = self.tcx.hir().body(encl_body_id);
 767
 768                 err.encl_body_span = Some(encl_body.value.span);
 769                 err.encl_fn_span = Some(*encl_fn_span);
 770             }
 771
 772             self.tcx.sess.emit_err(err);
 773
 774             if let Some(e) = expr_opt {
 775                 // We still have to type-check `e` (issue #86188), but calling
 776                 // `check_return_expr` only works inside fn bodies.
 777                 self.check_expr(e);
 778             }
 779         } else if let Some(e) = expr_opt {
 780             if self.ret_coercion_span.get().is_none() {
 781                 self.ret_coercion_span.set(Some(e.span));
 782             }
 783             self.check_return_expr(e, true);
 784         } else {
 785             let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
 786             if self.ret_coercion_span.get().is_none() {
 787                 self.ret_coercion_span.set(Some(expr.span));
 788             }
 789             let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
 790             if let Some((fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
 791                 coercion.coerce_forced_unit(
 792                     self,
 793                     &cause,
 794                     &mut |db| {
 795                         let span = fn_decl.output.span();
 796                         if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
 797                             db.span_label(
 798                                 span,
 799                                 format!("expected `{snippet}` because of this return type"),
 800                             );
 801                         }
 802                     },
 803                     true,
 804                 );
 805             } else {
 806                 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
 807             }
 808         }
 809         self.tcx.types.never
 810     }
 811
 812     /// `explicit_return` is `true` if we're checking an explicit `return expr`,
 813     /// and `false` if we're checking a trailing expression.
 814     pub(super) fn check_return_expr(
 815         &self,
 816         return_expr: &'tcx hir::Expr<'tcx>,
 817         explicit_return: bool,
 818     ) {
 819         let ret_coercion = self.ret_coercion.as_ref().unwrap_or_else(|| {
 820             span_bug!(return_expr.span, "check_return_expr called outside fn body")
 821         });
 822
 823         let ret_ty = ret_coercion.borrow().expected_ty();
 824         let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty);
 825         let mut span = return_expr.span;
 826         // Use the span of the trailing expression for our cause,
 827         // not the span of the entire function
 828         if !explicit_return {
 829             if let ExprKind::Block(body, _) = return_expr.kind && let Some(last_expr) = body.expr {
 830                 span = last_expr.span;
 831             }
 832         }
 833         ret_coercion.borrow_mut().coerce(
 834             self,
 835             &self.cause(span, ObligationCauseCode::ReturnValue(return_expr.hir_id)),
 836             return_expr,
 837             return_expr_ty,
 838         );
 839
 840         if let Some(fn_sig) = self.body_fn_sig()
 841             && fn_sig.output().has_opaque_types()
 842         {
 843             // Point any obligations that were registered due to opaque type
 844             // inference at the return expression.
 845             self.select_obligations_where_possible(|errors| {
 846                 self.point_at_return_for_opaque_ty_error(errors, span, return_expr_ty);
 847             });
 848         }
 849     }
 850
 851     fn point_at_return_for_opaque_ty_error(
 852         &self,
 853         errors: &mut Vec<traits::FulfillmentError<'tcx>>,
 854         span: Span,
 855         return_expr_ty: Ty<'tcx>,
 856     ) {
 857         // Don't point at the whole block if it's empty
 858         if span == self.tcx.hir().span(self.body_id) {
 859             return;
 860         }
 861         for err in errors {
 862             let cause = &mut err.obligation.cause;
 863             if let ObligationCauseCode::OpaqueReturnType(None) = cause.code() {
 864                 let new_cause = ObligationCause::new(
 865                     cause.span,
 866                     cause.body_id,
 867                     ObligationCauseCode::OpaqueReturnType(Some((return_expr_ty, span))),
 868                 );
 869                 *cause = new_cause;
 870             }
 871         }
 872     }
 873
 874     pub(crate) fn check_lhs_assignable(
 875         &self,
 876         lhs: &'tcx hir::Expr<'tcx>,
 877         err_code: &'static str,
 878         op_span: Span,
 879         adjust_err: impl FnOnce(&mut Diagnostic),
 880     ) {
 881         if lhs.is_syntactic_place_expr() {
 882             return;
 883         }
 884
 885         // FIXME: Make this use Diagnostic once error codes can be dynamically set.
 886         let mut err = self.tcx.sess.struct_span_err_with_code(
 887             op_span,
 888             "invalid left-hand side of assignment",
 889             DiagnosticId::Error(err_code.into()),
 890         );
 891         err.span_label(lhs.span, "cannot assign to this expression");
 892
 893         self.comes_from_while_condition(lhs.hir_id, |expr| {
 894             err.span_suggestion_verbose(
 895                 expr.span.shrink_to_lo(),
 896                 "you might have meant to use pattern destructuring",
 897                 "let ",
 898                 Applicability::MachineApplicable,
 899             );
 900         });
 901
 902         adjust_err(&mut err);
 903
 904         err.emit();
 905     }
 906
 907     // Check if an expression `original_expr_id` comes from the condition of a while loop,
 908     // as opposed from the body of a while loop, which we can naively check by iterating
 909     // parents until we find a loop...
 910     pub(super) fn comes_from_while_condition(
 911         &self,
 912         original_expr_id: HirId,
 913         then: impl FnOnce(&hir::Expr<'_>),
 914     ) {
 915         let mut parent = self.tcx.hir().get_parent_node(original_expr_id);
 916         while let Some(node) = self.tcx.hir().find(parent) {
 917             match node {
 918                 hir::Node::Expr(hir::Expr {
 919                     kind:
 920                         hir::ExprKind::Loop(
 921                             hir::Block {
 922                                 expr:
 923                                     Some(hir::Expr {
 924                                         kind:
 925                                             hir::ExprKind::Match(expr, ..) | hir::ExprKind::If(expr, ..),
 926                                         ..
 927                                     }),
 928                                 ..
 929                             },
 930                             _,
 931                             hir::LoopSource::While,
 932                             _,
 933                         ),
 934                     ..
 935                 }) => {
 936                     // Check if our original expression is a child of the condition of a while loop
 937                     let expr_is_ancestor = std::iter::successors(Some(original_expr_id), |id| {
 938                         self.tcx.hir().find_parent_node(*id)
 939                     })
 940                     .take_while(|id| *id != parent)
 941                     .any(|id| id == expr.hir_id);
 942                     // if it is, then we have a situation like `while Some(0) = value.get(0) {`,
 943                     // where `while let` was more likely intended.
 944                     if expr_is_ancestor {
 945                         then(expr);
 946                     }
 947                     break;
 948                 }
 949                 hir::Node::Item(_)
 950                 | hir::Node::ImplItem(_)
 951                 | hir::Node::TraitItem(_)
 952                 | hir::Node::Crate(_) => break,
 953                 _ => {
 954                     parent = self.tcx.hir().get_parent_node(parent);
 955                 }
 956             }
 957         }
 958     }
 959
 960     // A generic function for checking the 'then' and 'else' clauses in an 'if'
 961     // or 'if-else' expression.
 962     fn check_then_else(
 963         &self,
 964         cond_expr: &'tcx hir::Expr<'tcx>,
 965         then_expr: &'tcx hir::Expr<'tcx>,
 966         opt_else_expr: Option<&'tcx hir::Expr<'tcx>>,
 967         sp: Span,
 968         orig_expected: Expectation<'tcx>,
 969     ) -> Ty<'tcx> {
 970         let cond_ty = self.check_expr_has_type_or_error(cond_expr, self.tcx.types.bool, |_| {});
 971
 972         self.warn_if_unreachable(
 973             cond_expr.hir_id,
 974             then_expr.span,
 975             "block in `if` or `while` expression",
 976         );
 977
 978         let cond_diverges = self.diverges.get();
 979         self.diverges.set(Diverges::Maybe);
 980
 981         let expected = orig_expected.adjust_for_branches(self);
 982         let then_ty = self.check_expr_with_expectation(then_expr, expected);
 983         let then_diverges = self.diverges.get();
 984         self.diverges.set(Diverges::Maybe);
 985
 986         // We've already taken the expected type's preferences
 987         // into account when typing the `then` branch. To figure
 988         // out the initial shot at a LUB, we thus only consider
 989         // `expected` if it represents a *hard* constraint
 990         // (`only_has_type`); otherwise, we just go with a
 991         // fresh type variable.
 992         let coerce_to_ty = expected.coercion_target_type(self, sp);
 993         let mut coerce: DynamicCoerceMany<'_> = CoerceMany::new(coerce_to_ty);
 994
 995         coerce.coerce(self, &self.misc(sp), then_expr, then_ty);
 996
 997         if let Some(else_expr) = opt_else_expr {
 998             let else_ty = self.check_expr_with_expectation(else_expr, expected);
 999             let else_diverges = self.diverges.get();
1000
1001             let opt_suggest_box_span = self.opt_suggest_box_span(then_ty, else_ty, orig_expected);
1002             let if_cause = self.if_cause(
1003                 sp,
1004                 cond_expr.span,
1005                 then_expr,
1006                 else_expr,
1007                 then_ty,
1008                 else_ty,
1009                 opt_suggest_box_span,
1010             );
1011
1012             coerce.coerce(self, &if_cause, else_expr, else_ty);
1013
1014             // We won't diverge unless both branches do (or the condition does).
1015             self.diverges.set(cond_diverges | then_diverges & else_diverges);
1016         } else {
1017             self.if_fallback_coercion(sp, then_expr, &mut coerce);
1018
1019             // If the condition is false we can't diverge.
1020             self.diverges.set(cond_diverges);
1021         }
1022
1023         let result_ty = coerce.complete(self);
1024         if cond_ty.references_error() { self.tcx.ty_error() } else { result_ty }
1025     }
1026
1027     /// Type check assignment expression `expr` of form `lhs = rhs`.
1028     /// The expected type is `()` and is passed to the function for the purposes of diagnostics.
1029     fn check_expr_assign(
1030         &self,
1031         expr: &'tcx hir::Expr<'tcx>,
1032         expected: Expectation<'tcx>,
1033         lhs: &'tcx hir::Expr<'tcx>,
1034         rhs: &'tcx hir::Expr<'tcx>,
1035         span: Span,
1036     ) -> Ty<'tcx> {
1037         let expected_ty = expected.coercion_target_type(self, expr.span);
1038         if expected_ty == self.tcx.types.bool {
1039             // The expected type is `bool` but this will result in `()` so we can reasonably
1040             // say that the user intended to write `lhs == rhs` instead of `lhs = rhs`.
1041             // The likely cause of this is `if foo = bar { .. }`.
1042             let actual_ty = self.tcx.mk_unit();
1043             let mut err = self.demand_suptype_diag(expr.span, expected_ty, actual_ty).unwrap();
1044             let lhs_ty = self.check_expr(&lhs);
1045             let rhs_ty = self.check_expr(&rhs);
1046             let (applicability, eq) = if self.can_coerce(rhs_ty, lhs_ty) {
1047                 (Applicability::MachineApplicable, true)
1048             } else if let ExprKind::Binary(
1049                 Spanned { node: hir::BinOpKind::And | hir::BinOpKind::Or, .. },
1050                 _,
1051                 rhs_expr,
1052             ) = lhs.kind
1053             {
1054                 // if x == 1 && y == 2 { .. }
1055                 //                 +
1056                 let actual_lhs_ty = self.check_expr(&rhs_expr);
1057                 (Applicability::MaybeIncorrect, self.can_coerce(rhs_ty, actual_lhs_ty))
1058             } else if let ExprKind::Binary(
1059                 Spanned { node: hir::BinOpKind::And | hir::BinOpKind::Or, .. },
1060                 lhs_expr,
1061                 _,
1062             ) = rhs.kind
1063             {
1064                 // if x == 1 && y == 2 { .. }
1065                 //       +
1066                 let actual_rhs_ty = self.check_expr(&lhs_expr);
1067                 (Applicability::MaybeIncorrect, self.can_coerce(actual_rhs_ty, lhs_ty))
1068             } else {
1069                 (Applicability::MaybeIncorrect, false)
1070             };
1071             if !lhs.is_syntactic_place_expr()
1072                 && lhs.is_approximately_pattern()
1073                 && !matches!(lhs.kind, hir::ExprKind::Lit(_))
1074             {
1075                 // Do not suggest `if let x = y` as `==` is way more likely to be the intention.
1076                 let hir = self.tcx.hir();
1077                 if let hir::Node::Expr(hir::Expr { kind: ExprKind::If { .. }, .. }) =
1078                     hir.get(hir.get_parent_node(hir.get_parent_node(expr.hir_id)))
1079                 {
1080                     err.span_suggestion_verbose(
1081                         expr.span.shrink_to_lo(),
1082                         "you might have meant to use pattern matching",
1083                         "let ",
1084                         applicability,
1085                     );
1086                 };
1087             }
1088             if eq {
1089                 err.span_suggestion_verbose(
1090                     span.shrink_to_hi(),
1091                     "you might have meant to compare for equality",
1092                     '=',
1093                     applicability,
1094                 );
1095             }
1096
1097             // If the assignment expression itself is ill-formed, don't
1098             // bother emitting another error
1099             let reported = err.emit_unless(lhs_ty.references_error() || rhs_ty.references_error());
1100             return self.tcx.ty_error_with_guaranteed(reported);
1101         }
1102
1103         let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
1104
1105         let suggest_deref_binop = |err: &mut Diagnostic, rhs_ty: Ty<'tcx>| {
1106             if let Some(lhs_deref_ty) = self.deref_once_mutably_for_diagnostic(lhs_ty) {
1107                 // Can only assign if the type is sized, so if `DerefMut` yields a type that is
1108                 // unsized, do not suggest dereferencing it.
1109                 let lhs_deref_ty_is_sized = self
1110                     .infcx
1111                     .type_implements_trait(
1112                         self.tcx.lang_items().sized_trait().unwrap(),
1113                         lhs_deref_ty,
1114                         ty::List::empty(),
1115                         self.param_env,
1116                     )
1117                     .may_apply();
1118                 if lhs_deref_ty_is_sized && self.can_coerce(rhs_ty, lhs_deref_ty) {
1119                     err.span_suggestion_verbose(
1120                         lhs.span.shrink_to_lo(),
1121                         "consider dereferencing here to assign to the mutably borrowed value",
1122                         "*",
1123                         Applicability::MachineApplicable,
1124                     );
1125                 }
1126             }
1127         };
1128
1129         // This is (basically) inlined `check_expr_coercable_to_type`, but we want
1130         // to suggest an additional fixup here in `suggest_deref_binop`.
1131         let rhs_ty = self.check_expr_with_hint(&rhs, lhs_ty);
1132         if let (_, Some(mut diag)) =
1133             self.demand_coerce_diag(rhs, rhs_ty, lhs_ty, Some(lhs), AllowTwoPhase::No)
1134         {
1135             suggest_deref_binop(&mut diag, rhs_ty);
1136             diag.emit();
1137         }
1138
1139         self.check_lhs_assignable(lhs, "E0070", span, |err| {
1140             if let Some(rhs_ty) = self.typeck_results.borrow().expr_ty_opt(rhs) {
1141                 suggest_deref_binop(err, rhs_ty);
1142             }
1143         });
1144
1145         self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
1146
1147         if lhs_ty.references_error() || rhs_ty.references_error() {
1148             self.tcx.ty_error()
1149         } else {
1150             self.tcx.mk_unit()
1151         }
1152     }
1153
1154     pub(super) fn check_expr_let(&self, let_expr: &'tcx hir::Let<'tcx>) -> Ty<'tcx> {
1155         // for let statements, this is done in check_stmt
1156         let init = let_expr.init;
1157         self.warn_if_unreachable(init.hir_id, init.span, "block in `let` expression");
1158         // otherwise check exactly as a let statement
1159         self.check_decl(let_expr.into());
1160         // but return a bool, for this is a boolean expression
1161         self.tcx.types.bool
1162     }
1163
1164     fn check_expr_loop(
1165         &self,
1166         body: &'tcx hir::Block<'tcx>,
1167         source: hir::LoopSource,
1168         expected: Expectation<'tcx>,
1169         expr: &'tcx hir::Expr<'tcx>,
1170     ) -> Ty<'tcx> {
1171         let coerce = match source {
1172             // you can only use break with a value from a normal `loop { }`
1173             hir::LoopSource::Loop => {
1174                 let coerce_to = expected.coercion_target_type(self, body.span);
1175                 Some(CoerceMany::new(coerce_to))
1176             }
1177
1178             hir::LoopSource::While | hir::LoopSource::ForLoop => None,
1179         };
1180
1181         let ctxt = BreakableCtxt {
1182             coerce,
1183             may_break: false, // Will get updated if/when we find a `break`.
1184         };
1185
1186         let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
1187             self.check_block_no_value(&body);
1188         });
1189
1190         if ctxt.may_break {
1191             // No way to know whether it's diverging because
1192             // of a `break` or an outer `break` or `return`.
1193             self.diverges.set(Diverges::Maybe);
1194         }
1195
1196         // If we permit break with a value, then result type is
1197         // the LUB of the breaks (possibly ! if none); else, it
1198         // is nil. This makes sense because infinite loops
1199         // (which would have type !) are only possible iff we
1200         // permit break with a value [1].
1201         if ctxt.coerce.is_none() && !ctxt.may_break {
1202             // [1]
1203             self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
1204         }
1205         ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
1206     }
1207
1208     /// Checks a method call.
1209     fn check_method_call(
1210         &self,
1211         expr: &'tcx hir::Expr<'tcx>,
1212         segment: &hir::PathSegment<'_>,
1213         rcvr: &'tcx hir::Expr<'tcx>,
1214         args: &'tcx [hir::Expr<'tcx>],
1215         expected: Expectation<'tcx>,
1216     ) -> Ty<'tcx> {
1217         let rcvr_t = self.check_expr(&rcvr);
1218         // no need to check for bot/err -- callee does that
1219         let rcvr_t = self.structurally_resolved_type(rcvr.span, rcvr_t);
1220         let span = segment.ident.span;
1221
1222         let method = match self.lookup_method(rcvr_t, segment, span, expr, rcvr, args) {
1223             Ok(method) => {
1224                 // We could add a "consider `foo::<params>`" suggestion here, but I wasn't able to
1225                 // trigger this codepath causing `structurally_resolved_type` to emit an error.
1226
1227                 self.write_method_call(expr.hir_id, method);
1228                 Ok(method)
1229             }
1230             Err(error) => {
1231                 if segment.ident.name != kw::Empty {
1232                     if let Some(mut err) = self.report_method_error(
1233                         span,
1234                         rcvr_t,
1235                         segment.ident,
1236                         SelfSource::MethodCall(rcvr),
1237                         error,
1238                         Some((rcvr, args)),
1239                     ) {
1240                         err.emit();
1241                     }
1242                 }
1243                 Err(())
1244             }
1245         };
1246
1247         // Call the generic checker.
1248         self.check_method_argument_types(span, expr, method, &args, DontTupleArguments, expected)
1249     }
1250
1251     fn check_expr_cast(
1252         &self,
1253         e: &'tcx hir::Expr<'tcx>,
1254         t: &'tcx hir::Ty<'tcx>,
1255         expr: &'tcx hir::Expr<'tcx>,
1256     ) -> Ty<'tcx> {
1257         // Find the type of `e`. Supply hints based on the type we are casting to,
1258         // if appropriate.
1259         let t_cast = self.to_ty_saving_user_provided_ty(t);
1260         let t_cast = self.resolve_vars_if_possible(t_cast);
1261         let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
1262         let t_expr = self.resolve_vars_if_possible(t_expr);
1263
1264         // Eagerly check for some obvious errors.
1265         if t_expr.references_error() || t_cast.references_error() {
1266             self.tcx.ty_error()
1267         } else {
1268             // Defer other checks until we're done type checking.
1269             let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
1270             match cast::CastCheck::new(
1271                 self,
1272                 e,
1273                 t_expr,
1274                 t_cast,
1275                 t.span,
1276                 expr.span,
1277                 self.param_env.constness(),
1278             ) {
1279                 Ok(cast_check) => {
1280                     debug!(
1281                         "check_expr_cast: deferring cast from {:?} to {:?}: {:?}",
1282                         t_cast, t_expr, cast_check,
1283                     );
1284                     deferred_cast_checks.push(cast_check);
1285                     t_cast
1286                 }
1287                 Err(_) => self.tcx.ty_error(),
1288             }
1289         }
1290     }
1291
1292     fn check_expr_array(
1293         &self,
1294         args: &'tcx [hir::Expr<'tcx>],
1295         expected: Expectation<'tcx>,
1296         expr: &'tcx hir::Expr<'tcx>,
1297     ) -> Ty<'tcx> {
1298         let element_ty = if !args.is_empty() {
1299             let coerce_to = expected
1300                 .to_option(self)
1301                 .and_then(|uty| match *uty.kind() {
1302                     ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
1303                     _ => None,
1304                 })
1305                 .unwrap_or_else(|| {
1306                     self.next_ty_var(TypeVariableOrigin {
1307                         kind: TypeVariableOriginKind::TypeInference,
1308                         span: expr.span,
1309                     })
1310                 });
1311             let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
1312             assert_eq!(self.diverges.get(), Diverges::Maybe);
1313             for e in args {
1314                 let e_ty = self.check_expr_with_hint(e, coerce_to);
1315                 let cause = self.misc(e.span);
1316                 coerce.coerce(self, &cause, e, e_ty);
1317             }
1318             coerce.complete(self)
1319         } else {
1320             self.next_ty_var(TypeVariableOrigin {
1321                 kind: TypeVariableOriginKind::TypeInference,
1322                 span: expr.span,
1323             })
1324         };
1325         let array_len = args.len() as u64;
1326         self.suggest_array_len(expr, array_len);
1327         self.tcx.mk_array(element_ty, array_len)
1328     }
1329
1330     fn suggest_array_len(&self, expr: &'tcx hir::Expr<'tcx>, array_len: u64) {
1331         let parent_node = self.tcx.hir().parent_iter(expr.hir_id).find(|(_, node)| {
1332             !matches!(node, hir::Node::Expr(hir::Expr { kind: hir::ExprKind::AddrOf(..), .. }))
1333         });
1334         let Some((_,
1335             hir::Node::Local(hir::Local { ty: Some(ty), .. })
1336             | hir::Node::Item(hir::Item { kind: hir::ItemKind::Const(ty, _), .. }))
1337         ) = parent_node else {
1338             return
1339         };
1340         if let hir::TyKind::Array(_, length) = ty.peel_refs().kind
1341             && let hir::ArrayLen::Body(hir::AnonConst { hir_id, .. }) = length
1342             && let Some(span) = self.tcx.hir().opt_span(hir_id)
1343         {
1344             match self.tcx.sess.diagnostic().steal_diagnostic(span, StashKey::UnderscoreForArrayLengths) {
1345                 Some(mut err) => {
1346                     err.span_suggestion(
1347                         span,
1348                         "consider specifying the array length",
1349                         array_len,
1350                         Applicability::MaybeIncorrect,
1351                     );
1352                     err.emit();
1353                 }
1354                 None => ()
1355             }
1356         }
1357     }
1358
1359     fn check_expr_const_block(
1360         &self,
1361         anon_const: &'tcx hir::AnonConst,
1362         expected: Expectation<'tcx>,
1363         _expr: &'tcx hir::Expr<'tcx>,
1364     ) -> Ty<'tcx> {
1365         let body = self.tcx.hir().body(anon_const.body);
1366
1367         // Create a new function context.
1368         let fcx = FnCtxt::new(self, self.param_env.with_const(), body.value.hir_id);
1369         crate::GatherLocalsVisitor::new(&fcx).visit_body(body);
1370
1371         let ty = fcx.check_expr_with_expectation(&body.value, expected);
1372         fcx.require_type_is_sized(ty, body.value.span, traits::ConstSized);
1373         fcx.write_ty(anon_const.hir_id, ty);
1374         ty
1375     }
1376
1377     fn check_expr_repeat(
1378         &self,
1379         element: &'tcx hir::Expr<'tcx>,
1380         count: &'tcx hir::ArrayLen,
1381         expected: Expectation<'tcx>,
1382         expr: &'tcx hir::Expr<'tcx>,
1383     ) -> Ty<'tcx> {
1384         let tcx = self.tcx;
1385         let count = self.array_length_to_const(count);
1386         if let Some(count) = count.try_eval_usize(tcx, self.param_env) {
1387             self.suggest_array_len(expr, count);
1388         }
1389
1390         let uty = match expected {
1391             ExpectHasType(uty) => match *uty.kind() {
1392                 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
1393                 _ => None,
1394             },
1395             _ => None,
1396         };
1397
1398         let (element_ty, t) = match uty {
1399             Some(uty) => {
1400                 self.check_expr_coercable_to_type(&element, uty, None);
1401                 (uty, uty)
1402             }
1403             None => {
1404                 let ty = self.next_ty_var(TypeVariableOrigin {
1405                     kind: TypeVariableOriginKind::MiscVariable,
1406                     span: element.span,
1407                 });
1408                 let element_ty = self.check_expr_has_type_or_error(&element, ty, |_| {});
1409                 (element_ty, ty)
1410             }
1411         };
1412
1413         if element_ty.references_error() {
1414             return tcx.ty_error();
1415         }
1416
1417         self.check_repeat_element_needs_copy_bound(element, count, element_ty);
1418
1419         tcx.mk_ty(ty::Array(t, count))
1420     }
1421
1422     fn check_repeat_element_needs_copy_bound(
1423         &self,
1424         element: &hir::Expr<'_>,
1425         count: ty::Const<'tcx>,
1426         element_ty: Ty<'tcx>,
1427     ) {
1428         let tcx = self.tcx;
1429         // Actual constants as the repeat element get inserted repeatedly instead of getting copied via Copy.
1430         match &element.kind {
1431             hir::ExprKind::ConstBlock(..) => return,
1432             hir::ExprKind::Path(qpath) => {
1433                 let res = self.typeck_results.borrow().qpath_res(qpath, element.hir_id);
1434                 if let Res::Def(DefKind::Const | DefKind::AssocConst | DefKind::AnonConst, _) = res
1435                 {
1436                     return;
1437                 }
1438             }
1439             _ => {}
1440         }
1441         // If someone calls a const fn, they can extract that call out into a separate constant (or a const
1442         // block in the future), so we check that to tell them that in the diagnostic. Does not affect typeck.
1443         let is_const_fn = match element.kind {
1444             hir::ExprKind::Call(func, _args) => match *self.node_ty(func.hir_id).kind() {
1445                 ty::FnDef(def_id, _) => tcx.is_const_fn(def_id),
1446                 _ => false,
1447             },
1448             _ => false,
1449         };
1450
1451         // If the length is 0, we don't create any elements, so we don't copy any. If the length is 1, we
1452         // don't copy that one element, we move it. Only check for Copy if the length is larger.
1453         if count.try_eval_usize(tcx, self.param_env).map_or(true, |len| len > 1) {
1454             let lang_item = self.tcx.require_lang_item(LangItem::Copy, None);
1455             let code = traits::ObligationCauseCode::RepeatElementCopy { is_const_fn };
1456             self.require_type_meets(element_ty, element.span, code, lang_item);
1457         }
1458     }
1459
1460     fn check_expr_tuple(
1461         &self,
1462         elts: &'tcx [hir::Expr<'tcx>],
1463         expected: Expectation<'tcx>,
1464         expr: &'tcx hir::Expr<'tcx>,
1465     ) -> Ty<'tcx> {
1466         let flds = expected.only_has_type(self).and_then(|ty| {
1467             let ty = self.resolve_vars_with_obligations(ty);
1468             match ty.kind() {
1469                 ty::Tuple(flds) => Some(&flds[..]),
1470                 _ => None,
1471             }
1472         });
1473
1474         let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| match flds {
1475             Some(fs) if i < fs.len() => {
1476                 let ety = fs[i];
1477                 self.check_expr_coercable_to_type(&e, ety, None);
1478                 ety
1479             }
1480             _ => self.check_expr_with_expectation(&e, NoExpectation),
1481         });
1482         let tuple = self.tcx.mk_tup(elt_ts_iter);
1483         if tuple.references_error() {
1484             self.tcx.ty_error()
1485         } else {
1486             self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
1487             tuple
1488         }
1489     }
1490
1491     fn check_expr_struct(
1492         &self,
1493         expr: &hir::Expr<'_>,
1494         expected: Expectation<'tcx>,
1495         qpath: &QPath<'_>,
1496         fields: &'tcx [hir::ExprField<'tcx>],
1497         base_expr: &'tcx Option<&'tcx hir::Expr<'tcx>>,
1498     ) -> Ty<'tcx> {
1499         // Find the relevant variant
1500         let Some((variant, adt_ty)) = self.check_struct_path(qpath, expr.hir_id) else {
1501             self.check_struct_fields_on_error(fields, base_expr);
1502             return self.tcx.ty_error();
1503         };
1504
1505         // Prohibit struct expressions when non-exhaustive flag is set.
1506         let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
1507         if !adt.did().is_local() && variant.is_field_list_non_exhaustive() {
1508             self.tcx
1509                 .sess
1510                 .emit_err(StructExprNonExhaustive { span: expr.span, what: adt.variant_descr() });
1511         }
1512
1513         self.check_expr_struct_fields(
1514             adt_ty,
1515             expected,
1516             expr.hir_id,
1517             qpath.span(),
1518             variant,
1519             fields,
1520             base_expr,
1521             expr.span,
1522         );
1523
1524         self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
1525         adt_ty
1526     }
1527
1528     fn check_expr_struct_fields(
1529         &self,
1530         adt_ty: Ty<'tcx>,
1531         expected: Expectation<'tcx>,
1532         expr_id: hir::HirId,
1533         span: Span,
1534         variant: &'tcx ty::VariantDef,
1535         ast_fields: &'tcx [hir::ExprField<'tcx>],
1536         base_expr: &'tcx Option<&'tcx hir::Expr<'tcx>>,
1537         expr_span: Span,
1538     ) {
1539         let tcx = self.tcx;
1540
1541         let expected_inputs =
1542             self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty]);
1543         let adt_ty_hint = if let Some(expected_inputs) = expected_inputs {
1544             expected_inputs.get(0).cloned().unwrap_or(adt_ty)
1545         } else {
1546             adt_ty
1547         };
1548         // re-link the regions that EIfEO can erase.
1549         self.demand_eqtype(span, adt_ty_hint, adt_ty);
1550
1551         let ty::Adt(adt, substs) = adt_ty.kind() else {
1552             span_bug!(span, "non-ADT passed to check_expr_struct_fields");
1553         };
1554         let adt_kind = adt.adt_kind();
1555
1556         let mut remaining_fields = variant
1557             .fields
1558             .iter()
1559             .enumerate()
1560             .map(|(i, field)| (field.ident(tcx).normalize_to_macros_2_0(), (i, field)))
1561             .collect::<FxHashMap<_, _>>();
1562
1563         let mut seen_fields = FxHashMap::default();
1564
1565         let mut error_happened = false;
1566
1567         // Type-check each field.
1568         for (idx, field) in ast_fields.iter().enumerate() {
1569             let ident = tcx.adjust_ident(field.ident, variant.def_id);
1570             let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
1571                 seen_fields.insert(ident, field.span);
1572                 self.write_field_index(field.hir_id, i);
1573
1574                 // We don't look at stability attributes on
1575                 // struct-like enums (yet...), but it's definitely not
1576                 // a bug to have constructed one.
1577                 if adt_kind != AdtKind::Enum {
1578                     tcx.check_stability(v_field.did, Some(expr_id), field.span, None);
1579                 }
1580
1581                 self.field_ty(field.span, v_field, substs)
1582             } else {
1583                 error_happened = true;
1584                 if let Some(prev_span) = seen_fields.get(&ident) {
1585                     tcx.sess.emit_err(FieldMultiplySpecifiedInInitializer {
1586                         span: field.ident.span,
1587                         prev_span: *prev_span,
1588                         ident,
1589                     });
1590                 } else {
1591                     self.report_unknown_field(
1592                         adt_ty,
1593                         variant,
1594                         field,
1595                         ast_fields,
1596                         adt.variant_descr(),
1597                         expr_span,
1598                     );
1599                 }
1600
1601                 tcx.ty_error()
1602             };
1603
1604             // Make sure to give a type to the field even if there's
1605             // an error, so we can continue type-checking.
1606             let ty = self.check_expr_with_hint(&field.expr, field_type);
1607             let (_, diag) =
1608                 self.demand_coerce_diag(&field.expr, ty, field_type, None, AllowTwoPhase::No);
1609
1610             if let Some(mut diag) = diag {
1611                 if idx == ast_fields.len() - 1 && remaining_fields.is_empty() {
1612                     self.suggest_fru_from_range(field, variant, substs, &mut diag);
1613                 }
1614                 diag.emit();
1615             }
1616         }
1617
1618         // Make sure the programmer specified correct number of fields.
1619         if adt_kind == AdtKind::Union {
1620             if ast_fields.len() != 1 {
1621                 struct_span_err!(
1622                     tcx.sess,
1623                     span,
1624                     E0784,
1625                     "union expressions should have exactly one field",
1626                 )
1627                 .emit();
1628             }
1629         }
1630
1631         // If check_expr_struct_fields hit an error, do not attempt to populate
1632         // the fields with the base_expr. This could cause us to hit errors later
1633         // when certain fields are assumed to exist that in fact do not.
1634         if error_happened {
1635             return;
1636         }
1637
1638         if let Some(base_expr) = base_expr {
1639             // FIXME: We are currently creating two branches here in order to maintain
1640             // consistency. But they should be merged as much as possible.
1641             let fru_tys = if self.tcx.features().type_changing_struct_update {
1642                 if adt.is_struct() {
1643                     // Make some fresh substitutions for our ADT type.
1644                     let fresh_substs = self.fresh_substs_for_item(base_expr.span, adt.did());
1645                     // We do subtyping on the FRU fields first, so we can
1646                     // learn exactly what types we expect the base expr
1647                     // needs constrained to be compatible with the struct
1648                     // type we expect from the expectation value.
1649                     let fru_tys = variant
1650                         .fields
1651                         .iter()
1652                         .map(|f| {
1653                             let fru_ty = self.normalize_associated_types_in(
1654                                 expr_span,
1655                                 self.field_ty(base_expr.span, f, fresh_substs),
1656                             );
1657                             let ident = self.tcx.adjust_ident(f.ident(self.tcx), variant.def_id);
1658                             if let Some(_) = remaining_fields.remove(&ident) {
1659                                 let target_ty = self.field_ty(base_expr.span, f, substs);
1660                                 let cause = self.misc(base_expr.span);
1661                                 match self.at(&cause, self.param_env).sup(target_ty, fru_ty) {
1662                                     Ok(InferOk { obligations, value: () }) => {
1663                                         self.register_predicates(obligations)
1664                                     }
1665                                     Err(_) => {
1666                                         // This should never happen, since we're just subtyping the
1667                                         // remaining_fields, but it's fine to emit this, I guess.
1668                                         self.err_ctxt()
1669                                             .report_mismatched_types(
1670                                                 &cause,
1671                                                 target_ty,
1672                                                 fru_ty,
1673                                                 FieldMisMatch(variant.name, ident.name),
1674                                             )
1675                                             .emit();
1676                                     }
1677                                 }
1678                             }
1679                             self.resolve_vars_if_possible(fru_ty)
1680                         })
1681                         .collect();
1682                     // The use of fresh substs that we have subtyped against
1683                     // our base ADT type's fields allows us to guide inference
1684                     // along so that, e.g.
1685                     // ```
1686                     // MyStruct<'a, F1, F2, const C: usize> {
1687                     //     f: F1,
1688                     //     // Other fields that reference `'a`, `F2`, and `C`
1689                     // }
1690                     //
1691                     // let x = MyStruct {
1692                     //    f: 1usize,
1693                     //    ..other_struct
1694                     // };
1695                     // ```
1696                     // will have the `other_struct` expression constrained to
1697                     // `MyStruct<'a, _, F2, C>`, as opposed to just `_`...
1698                     // This is important to allow coercions to happen in
1699                     // `other_struct` itself. See `coerce-in-base-expr.rs`.
1700                     let fresh_base_ty = self.tcx.mk_adt(*adt, fresh_substs);
1701                     self.check_expr_has_type_or_error(
1702                         base_expr,
1703                         self.resolve_vars_if_possible(fresh_base_ty),
1704                         |_| {},
1705                     );
1706                     fru_tys
1707                 } else {
1708                     // Check the base_expr, regardless of a bad expected adt_ty, so we can get
1709                     // type errors on that expression, too.
1710                     self.check_expr(base_expr);
1711                     self.tcx
1712                         .sess
1713                         .emit_err(FunctionalRecordUpdateOnNonStruct { span: base_expr.span });
1714                     return;
1715                 }
1716             } else {
1717                 self.check_expr_has_type_or_error(base_expr, adt_ty, |_| {
1718                     let base_ty = self.typeck_results.borrow().expr_ty(*base_expr);
1719                     let same_adt = match (adt_ty.kind(), base_ty.kind()) {
1720                         (ty::Adt(adt, _), ty::Adt(base_adt, _)) if adt == base_adt => true,
1721                         _ => false,
1722                     };
1723                     if self.tcx.sess.is_nightly_build() && same_adt {
1724                         feature_err(
1725                             &self.tcx.sess.parse_sess,
1726                             sym::type_changing_struct_update,
1727                             base_expr.span,
1728                             "type changing struct updating is experimental",
1729                         )
1730                         .emit();
1731                     }
1732                 });
1733                 match adt_ty.kind() {
1734                     ty::Adt(adt, substs) if adt.is_struct() => variant
1735                         .fields
1736                         .iter()
1737                         .map(|f| {
1738                             self.normalize_associated_types_in(expr_span, f.ty(self.tcx, substs))
1739                         })
1740                         .collect(),
1741                     _ => {
1742                         self.tcx
1743                             .sess
1744                             .emit_err(FunctionalRecordUpdateOnNonStruct { span: base_expr.span });
1745                         return;
1746                     }
1747                 }
1748             };
1749             self.typeck_results.borrow_mut().fru_field_types_mut().insert(expr_id, fru_tys);
1750         } else if adt_kind != AdtKind::Union && !remaining_fields.is_empty() {
1751             debug!(?remaining_fields);
1752             let private_fields: Vec<&ty::FieldDef> = variant
1753                 .fields
1754                 .iter()
1755                 .filter(|field| !field.vis.is_accessible_from(tcx.parent_module(expr_id), tcx))
1756                 .collect();
1757
1758             if !private_fields.is_empty() {
1759                 self.report_private_fields(adt_ty, span, private_fields, ast_fields);
1760             } else {
1761                 self.report_missing_fields(
1762                     adt_ty,
1763                     span,
1764                     remaining_fields,
1765                     variant,
1766                     ast_fields,
1767                     substs,
1768                 );
1769             }
1770         }
1771     }
1772
1773     fn check_struct_fields_on_error(
1774         &self,
1775         fields: &'tcx [hir::ExprField<'tcx>],
1776         base_expr: &'tcx Option<&'tcx hir::Expr<'tcx>>,
1777     ) {
1778         for field in fields {
1779             self.check_expr(&field.expr);
1780         }
1781         if let Some(base) = *base_expr {
1782             self.check_expr(&base);
1783         }
1784     }
1785
1786     /// Report an error for a struct field expression when there are fields which aren't provided.
1787     ///
1788     /// ```text
1789     /// error: missing field `you_can_use_this_field` in initializer of `foo::Foo`
1790     ///  --> src/main.rs:8:5
1791     ///   |
1792     /// 8 |     foo::Foo {};
1793     ///   |     ^^^^^^^^ missing `you_can_use_this_field`
1794     ///
1795     /// error: aborting due to previous error
1796     /// ```
1797     fn report_missing_fields(
1798         &self,
1799         adt_ty: Ty<'tcx>,
1800         span: Span,
1801         remaining_fields: FxHashMap<Ident, (usize, &ty::FieldDef)>,
1802         variant: &'tcx ty::VariantDef,
1803         ast_fields: &'tcx [hir::ExprField<'tcx>],
1804         substs: SubstsRef<'tcx>,
1805     ) {
1806         let len = remaining_fields.len();
1807
1808         let mut displayable_field_names: Vec<&str> =
1809             remaining_fields.keys().map(|ident| ident.as_str()).collect();
1810         // sorting &str primitives here, sort_unstable is ok
1811         displayable_field_names.sort_unstable();
1812
1813         let mut truncated_fields_error = String::new();
1814         let remaining_fields_names = match &displayable_field_names[..] {
1815             [field1] => format!("`{}`", field1),
1816             [field1, field2] => format!("`{field1}` and `{field2}`"),
1817             [field1, field2, field3] => format!("`{field1}`, `{field2}` and `{field3}`"),
1818             _ => {
1819                 truncated_fields_error =
1820                     format!(" and {} other field{}", len - 3, pluralize!(len - 3));
1821                 displayable_field_names
1822                     .iter()
1823                     .take(3)
1824                     .map(|n| format!("`{n}`"))
1825                     .collect::<Vec<_>>()
1826                     .join(", ")
1827             }
1828         };
1829
1830         let mut err = struct_span_err!(
1831             self.tcx.sess,
1832             span,
1833             E0063,
1834             "missing field{} {}{} in initializer of `{}`",
1835             pluralize!(len),
1836             remaining_fields_names,
1837             truncated_fields_error,
1838             adt_ty
1839         );
1840         err.span_label(span, format!("missing {remaining_fields_names}{truncated_fields_error}"));
1841
1842         if let Some(last) = ast_fields.last() {
1843             self.suggest_fru_from_range(last, variant, substs, &mut err);
1844         }
1845
1846         err.emit();
1847     }
1848
1849     /// If the last field is a range literal, but it isn't supposed to be, then they probably
1850     /// meant to use functional update syntax.
1851     fn suggest_fru_from_range(
1852         &self,
1853         last_expr_field: &hir::ExprField<'tcx>,
1854         variant: &ty::VariantDef,
1855         substs: SubstsRef<'tcx>,
1856         err: &mut Diagnostic,
1857     ) {
1858         // I don't use 'is_range_literal' because only double-sided, half-open ranges count.
1859         if let ExprKind::Struct(
1860                 QPath::LangItem(LangItem::Range, ..),
1861                 &[ref range_start, ref range_end],
1862                 _,
1863             ) = last_expr_field.expr.kind
1864             && let variant_field =
1865                 variant.fields.iter().find(|field| field.ident(self.tcx) == last_expr_field.ident)
1866             && let range_def_id = self.tcx.lang_items().range_struct()
1867             && variant_field
1868                 .and_then(|field| field.ty(self.tcx, substs).ty_adt_def())
1869                 .map(|adt| adt.did())
1870                 != range_def_id
1871         {
1872             let instead = self
1873                 .tcx
1874                 .sess
1875                 .source_map()
1876                 .span_to_snippet(range_end.expr.span)
1877                 .map(|s| format!(" from `{s}`"))
1878                 .unwrap_or_default();
1879             err.span_suggestion(
1880                 range_start.span.shrink_to_hi(),
1881                 &format!("to set the remaining fields{instead}, separate the last named field with a comma"),
1882                 ",",
1883                 Applicability::MaybeIncorrect,
1884             );
1885         }
1886     }
1887
1888     /// Report an error for a struct field expression when there are invisible fields.
1889     ///
1890     /// ```text
1891     /// error: cannot construct `Foo` with struct literal syntax due to private fields
1892     ///  --> src/main.rs:8:5
1893     ///   |
1894     /// 8 |     foo::Foo {};
1895     ///   |     ^^^^^^^^
1896     ///
1897     /// error: aborting due to previous error
1898     /// ```
1899     fn report_private_fields(
1900         &self,
1901         adt_ty: Ty<'tcx>,
1902         span: Span,
1903         private_fields: Vec<&ty::FieldDef>,
1904         used_fields: &'tcx [hir::ExprField<'tcx>],
1905     ) {
1906         let mut err = self.tcx.sess.struct_span_err(
1907             span,
1908             &format!(
1909                 "cannot construct `{adt_ty}` with struct literal syntax due to private fields",
1910             ),
1911         );
1912         let (used_private_fields, remaining_private_fields): (
1913             Vec<(Symbol, Span, bool)>,
1914             Vec<(Symbol, Span, bool)>,
1915         ) = private_fields
1916             .iter()
1917             .map(|field| {
1918                 match used_fields.iter().find(|used_field| field.name == used_field.ident.name) {
1919                     Some(used_field) => (field.name, used_field.span, true),
1920                     None => (field.name, self.tcx.def_span(field.did), false),
1921                 }
1922             })
1923             .partition(|field| field.2);
1924         err.span_labels(used_private_fields.iter().map(|(_, span, _)| *span), "private field");
1925         if !remaining_private_fields.is_empty() {
1926             let remaining_private_fields_len = remaining_private_fields.len();
1927             let names = match &remaining_private_fields
1928                 .iter()
1929                 .map(|(name, _, _)| name)
1930                 .collect::<Vec<_>>()[..]
1931             {
1932                 _ if remaining_private_fields_len > 6 => String::new(),
1933                 [name] => format!("`{name}` "),
1934                 [names @ .., last] => {
1935                     let names = names.iter().map(|name| format!("`{name}`")).collect::<Vec<_>>();
1936                     format!("{} and `{last}` ", names.join(", "))
1937                 }
1938                 [] => unreachable!(),
1939             };
1940             err.note(format!(
1941                 "... and other private field{s} {names}that {were} not provided",
1942                 s = pluralize!(remaining_private_fields_len),
1943                 were = pluralize!("was", remaining_private_fields_len),
1944             ));
1945         }
1946         err.emit();
1947     }
1948
1949     fn report_unknown_field(
1950         &self,
1951         ty: Ty<'tcx>,
1952         variant: &'tcx ty::VariantDef,
1953         field: &hir::ExprField<'_>,
1954         skip_fields: &[hir::ExprField<'_>],
1955         kind_name: &str,
1956         expr_span: Span,
1957     ) {
1958         if variant.is_recovered() {
1959             self.set_tainted_by_errors();
1960             return;
1961         }
1962         let mut err = self.err_ctxt().type_error_struct_with_diag(
1963             field.ident.span,
1964             |actual| match ty.kind() {
1965                 ty::Adt(adt, ..) if adt.is_enum() => struct_span_err!(
1966                     self.tcx.sess,
1967                     field.ident.span,
1968                     E0559,
1969                     "{} `{}::{}` has no field named `{}`",
1970                     kind_name,
1971                     actual,
1972                     variant.name,
1973                     field.ident
1974                 ),
1975                 _ => struct_span_err!(
1976                     self.tcx.sess,
1977                     field.ident.span,
1978                     E0560,
1979                     "{} `{}` has no field named `{}`",
1980                     kind_name,
1981                     actual,
1982                     field.ident
1983                 ),
1984             },
1985             ty,
1986         );
1987
1988         let variant_ident_span = self.tcx.def_ident_span(variant.def_id).unwrap();
1989         match variant.ctor_kind {
1990             CtorKind::Fn => match ty.kind() {
1991                 ty::Adt(adt, ..) if adt.is_enum() => {
1992                     err.span_label(
1993                         variant_ident_span,
1994                         format!(
1995                             "`{adt}::{variant}` defined here",
1996                             adt = ty,
1997                             variant = variant.name,
1998                         ),
1999                     );
2000                     err.span_label(field.ident.span, "field does not exist");
2001                     err.span_suggestion_verbose(
2002                         expr_span,
2003                         &format!(
2004                             "`{adt}::{variant}` is a tuple {kind_name}, use the appropriate syntax",
2005                             adt = ty,
2006                             variant = variant.name,
2007                         ),
2008                         format!(
2009                             "{adt}::{variant}(/* fields */)",
2010                             adt = ty,
2011                             variant = variant.name,
2012                         ),
2013                         Applicability::HasPlaceholders,
2014                     );
2015                 }
2016                 _ => {
2017                     err.span_label(variant_ident_span, format!("`{adt}` defined here", adt = ty));
2018                     err.span_label(field.ident.span, "field does not exist");
2019                     err.span_suggestion_verbose(
2020                         expr_span,
2021                         &format!(
2022                             "`{adt}` is a tuple {kind_name}, use the appropriate syntax",
2023                             adt = ty,
2024                             kind_name = kind_name,
2025                         ),
2026                         format!("{adt}(/* fields */)", adt = ty),
2027                         Applicability::HasPlaceholders,
2028                     );
2029                 }
2030             },
2031             _ => {
2032                 // prevent all specified fields from being suggested
2033                 let skip_fields = skip_fields.iter().map(|x| x.ident.name);
2034                 if let Some(field_name) = self.suggest_field_name(
2035                     variant,
2036                     field.ident.name,
2037                     skip_fields.collect(),
2038                     expr_span,
2039                 ) {
2040                     err.span_suggestion(
2041                         field.ident.span,
2042                         "a field with a similar name exists",
2043                         field_name,
2044                         Applicability::MaybeIncorrect,
2045                     );
2046                 } else {
2047                     match ty.kind() {
2048                         ty::Adt(adt, ..) => {
2049                             if adt.is_enum() {
2050                                 err.span_label(
2051                                     field.ident.span,
2052                                     format!("`{}::{}` does not have this field", ty, variant.name),
2053                                 );
2054                             } else {
2055                                 err.span_label(
2056                                     field.ident.span,
2057                                     format!("`{ty}` does not have this field"),
2058                                 );
2059                             }
2060                             let available_field_names =
2061                                 self.available_field_names(variant, expr_span);
2062                             if !available_field_names.is_empty() {
2063                                 err.note(&format!(
2064                                     "available fields are: {}",
2065                                     self.name_series_display(available_field_names)
2066                                 ));
2067                             }
2068                         }
2069                         _ => bug!("non-ADT passed to report_unknown_field"),
2070                     }
2071                 };
2072             }
2073         }
2074         err.emit();
2075     }
2076
2077     // Return a hint about the closest match in field names
2078     fn suggest_field_name(
2079         &self,
2080         variant: &'tcx ty::VariantDef,
2081         field: Symbol,
2082         skip: Vec<Symbol>,
2083         // The span where stability will be checked
2084         span: Span,
2085     ) -> Option<Symbol> {
2086         let names = variant
2087             .fields
2088             .iter()
2089             .filter_map(|field| {
2090                 // ignore already set fields and private fields from non-local crates
2091                 // and unstable fields.
2092                 if skip.iter().any(|&x| x == field.name)
2093                     || (!variant.def_id.is_local() && !field.vis.is_public())
2094                     || matches!(
2095                         self.tcx.eval_stability(field.did, None, span, None),
2096                         stability::EvalResult::Deny { .. }
2097                     )
2098                 {
2099                     None
2100                 } else {
2101                     Some(field.name)
2102                 }
2103             })
2104             .collect::<Vec<Symbol>>();
2105
2106         find_best_match_for_name(&names, field, None)
2107     }
2108
2109     fn available_field_names(
2110         &self,
2111         variant: &'tcx ty::VariantDef,
2112         access_span: Span,
2113     ) -> Vec<Symbol> {
2114         variant
2115             .fields
2116             .iter()
2117             .filter(|field| {
2118                 let def_scope = self
2119                     .tcx
2120                     .adjust_ident_and_get_scope(field.ident(self.tcx), variant.def_id, self.body_id)
2121                     .1;
2122                 field.vis.is_accessible_from(def_scope, self.tcx)
2123                     && !matches!(
2124                         self.tcx.eval_stability(field.did, None, access_span, None),
2125                         stability::EvalResult::Deny { .. }
2126                     )
2127             })
2128             .filter(|field| !self.tcx.is_doc_hidden(field.did))
2129             .map(|field| field.name)
2130             .collect()
2131     }
2132
2133     fn name_series_display(&self, names: Vec<Symbol>) -> String {
2134         // dynamic limit, to never omit just one field
2135         let limit = if names.len() == 6 { 6 } else { 5 };
2136         let mut display =
2137             names.iter().take(limit).map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
2138         if names.len() > limit {
2139             display = format!("{} ... and {} others", display, names.len() - limit);
2140         }
2141         display
2142     }
2143
2144     // Check field access expressions
2145     fn check_field(
2146         &self,
2147         expr: &'tcx hir::Expr<'tcx>,
2148         base: &'tcx hir::Expr<'tcx>,
2149         field: Ident,
2150     ) -> Ty<'tcx> {
2151         debug!("check_field(expr: {:?}, base: {:?}, field: {:?})", expr, base, field);
2152         let base_ty = self.check_expr(base);
2153         let base_ty = self.structurally_resolved_type(base.span, base_ty);
2154         let mut private_candidate = None;
2155         let mut autoderef = self.autoderef(expr.span, base_ty);
2156         while let Some((deref_base_ty, _)) = autoderef.next() {
2157             debug!("deref_base_ty: {:?}", deref_base_ty);
2158             match deref_base_ty.kind() {
2159                 ty::Adt(base_def, substs) if !base_def.is_enum() => {
2160                     debug!("struct named {:?}", deref_base_ty);
2161                     let (ident, def_scope) =
2162                         self.tcx.adjust_ident_and_get_scope(field, base_def.did(), self.body_id);
2163                     let fields = &base_def.non_enum_variant().fields;
2164                     if let Some(index) = fields
2165                         .iter()
2166                         .position(|f| f.ident(self.tcx).normalize_to_macros_2_0() == ident)
2167                     {
2168                         let field = &fields[index];
2169                         let field_ty = self.field_ty(expr.span, field, substs);
2170                         // Save the index of all fields regardless of their visibility in case
2171                         // of error recovery.
2172                         self.write_field_index(expr.hir_id, index);
2173                         let adjustments = self.adjust_steps(&autoderef);
2174                         if field.vis.is_accessible_from(def_scope, self.tcx) {
2175                             self.apply_adjustments(base, adjustments);
2176                             self.register_predicates(autoderef.into_obligations());
2177
2178                             self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span, None);
2179                             return field_ty;
2180                         }
2181                         private_candidate = Some((adjustments, base_def.did(), field_ty));
2182                     }
2183                 }
2184                 ty::Tuple(tys) => {
2185                     let fstr = field.as_str();
2186                     if let Ok(index) = fstr.parse::<usize>() {
2187                         if fstr == index.to_string() {
2188                             if let Some(&field_ty) = tys.get(index) {
2189                                 let adjustments = self.adjust_steps(&autoderef);
2190                                 self.apply_adjustments(base, adjustments);
2191                                 self.register_predicates(autoderef.into_obligations());
2192
2193                                 self.write_field_index(expr.hir_id, index);
2194                                 return field_ty;
2195                             }
2196                         }
2197                     }
2198                 }
2199                 _ => {}
2200             }
2201         }
2202         self.structurally_resolved_type(autoderef.span(), autoderef.final_ty(false));
2203
2204         if let Some((adjustments, did, field_ty)) = private_candidate {
2205             // (#90483) apply adjustments to avoid ExprUseVisitor from
2206             // creating erroneous projection.
2207             self.apply_adjustments(base, adjustments);
2208             self.ban_private_field_access(expr, base_ty, field, did);
2209             return field_ty;
2210         }
2211
2212         if field.name == kw::Empty {
2213         } else if self.method_exists(field, base_ty, expr.hir_id, true) {
2214             self.ban_take_value_of_method(expr, base_ty, field);
2215         } else if !base_ty.is_primitive_ty() {
2216             self.ban_nonexisting_field(field, base, expr, base_ty);
2217         } else {
2218             let field_name = field.to_string();
2219             let mut err = type_error_struct!(
2220                 self.tcx().sess,
2221                 field.span,
2222                 base_ty,
2223                 E0610,
2224                 "`{base_ty}` is a primitive type and therefore doesn't have fields",
2225             );
2226             let is_valid_suffix = |field: &str| {
2227                 if field == "f32" || field == "f64" {
2228                     return true;
2229                 }
2230                 let mut chars = field.chars().peekable();
2231                 match chars.peek() {
2232                     Some('e') | Some('E') => {
2233                         chars.next();
2234                         if let Some(c) = chars.peek()
2235                             && !c.is_numeric() && *c != '-' && *c != '+'
2236                         {
2237                             return false;
2238                         }
2239                         while let Some(c) = chars.peek() {
2240                             if !c.is_numeric() {
2241                                 break;
2242                             }
2243                             chars.next();
2244                         }
2245                     }
2246                     _ => (),
2247                 }
2248                 let suffix = chars.collect::<String>();
2249                 suffix.is_empty() || suffix == "f32" || suffix == "f64"
2250             };
2251             let maybe_partial_suffix = |field: &str| -> Option<&str> {
2252                 let first_chars = ['f', 'l'];
2253                 if field.len() >= 1
2254                     && field.to_lowercase().starts_with(first_chars)
2255                     && field[1..].chars().all(|c| c.is_ascii_digit())
2256                 {
2257                     if field.to_lowercase().starts_with(['f']) { Some("f32") } else { Some("f64") }
2258                 } else {
2259                     None
2260                 }
2261             };
2262             if let ty::Infer(ty::IntVar(_)) = base_ty.kind()
2263                 && let ExprKind::Lit(Spanned {
2264                     node: ast::LitKind::Int(_, ast::LitIntType::Unsuffixed),
2265                     ..
2266                 }) = base.kind
2267                 && !base.span.from_expansion()
2268             {
2269                 if is_valid_suffix(&field_name) {
2270                     err.span_suggestion_verbose(
2271                         field.span.shrink_to_lo(),
2272                         "if intended to be a floating point literal, consider adding a `0` after the period",
2273                         '0',
2274                         Applicability::MaybeIncorrect,
2275                     );
2276                 } else if let Some(correct_suffix) = maybe_partial_suffix(&field_name) {
2277                     err.span_suggestion_verbose(
2278                         field.span,
2279                         format!("if intended to be a floating point literal, consider adding a `0` after the period and a `{correct_suffix}` suffix"),
2280                         format!("0{correct_suffix}"),
2281                         Applicability::MaybeIncorrect,
2282                     );
2283                 }
2284             }
2285             err.emit();
2286         }
2287
2288         self.tcx().ty_error()
2289     }
2290
2291     fn suggest_await_on_field_access(
2292         &self,
2293         err: &mut Diagnostic,
2294         field_ident: Ident,
2295         base: &'tcx hir::Expr<'tcx>,
2296         ty: Ty<'tcx>,
2297     ) {
2298         let output_ty = match self.get_impl_future_output_ty(ty) {
2299             Some(output_ty) => self.resolve_vars_if_possible(output_ty),
2300             _ => return,
2301         };
2302         let mut add_label = true;
2303         if let ty::Adt(def, _) = output_ty.skip_binder().kind() {
2304             // no field access on enum type
2305             if !def.is_enum() {
2306                 if def
2307                     .non_enum_variant()
2308                     .fields
2309                     .iter()
2310                     .any(|field| field.ident(self.tcx) == field_ident)
2311                 {
2312                     add_label = false;
2313                     err.span_label(
2314                         field_ident.span,
2315                         "field not available in `impl Future`, but it is available in its `Output`",
2316                     );
2317                     err.span_suggestion_verbose(
2318                         base.span.shrink_to_hi(),
2319                         "consider `await`ing on the `Future` and access the field of its `Output`",
2320                         ".await",
2321                         Applicability::MaybeIncorrect,
2322                     );
2323                 }
2324             }
2325         }
2326         if add_label {
2327             err.span_label(field_ident.span, &format!("field not found in `{ty}`"));
2328         }
2329     }
2330
2331     fn ban_nonexisting_field(
2332         &self,
2333         ident: Ident,
2334         base: &'tcx hir::Expr<'tcx>,
2335         expr: &'tcx hir::Expr<'tcx>,
2336         base_ty: Ty<'tcx>,
2337     ) {
2338         debug!(
2339             "ban_nonexisting_field: field={:?}, base={:?}, expr={:?}, base_ty={:?}",
2340             ident, base, expr, base_ty
2341         );
2342         let mut err = self.no_such_field_err(ident, base_ty, base.hir_id);
2343
2344         match *base_ty.peel_refs().kind() {
2345             ty::Array(_, len) => {
2346                 self.maybe_suggest_array_indexing(&mut err, expr, base, ident, len);
2347             }
2348             ty::RawPtr(..) => {
2349                 self.suggest_first_deref_field(&mut err, expr, base, ident);
2350             }
2351             ty::Adt(def, _) if !def.is_enum() => {
2352                 self.suggest_fields_on_recordish(&mut err, def, ident, expr.span);
2353             }
2354             ty::Param(param_ty) => {
2355                 self.point_at_param_definition(&mut err, param_ty);
2356             }
2357             ty::Opaque(_, _) => {
2358                 self.suggest_await_on_field_access(&mut err, ident, base, base_ty.peel_refs());
2359             }
2360             _ => {}
2361         }
2362
2363         self.suggest_fn_call(&mut err, base, base_ty, |output_ty| {
2364             if let ty::Adt(def, _) = output_ty.kind() && !def.is_enum() {
2365                 def.non_enum_variant().fields.iter().any(|field| {
2366                     field.ident(self.tcx) == ident
2367                         && field.vis.is_accessible_from(expr.hir_id.owner.def_id, self.tcx)
2368                 })
2369             } else if let ty::Tuple(tys) = output_ty.kind()
2370                 && let Ok(idx) = ident.as_str().parse::<usize>()
2371             {
2372                 idx < tys.len()
2373             } else {
2374                 false
2375             }
2376         });
2377
2378         if ident.name == kw::Await {
2379             // We know by construction that `<expr>.await` is either on Rust 2015
2380             // or results in `ExprKind::Await`. Suggest switching the edition to 2018.
2381             err.note("to `.await` a `Future`, switch to Rust 2018 or later");
2382             err.help_use_latest_edition();
2383         }
2384
2385         err.emit();
2386     }
2387
2388     fn ban_private_field_access(
2389         &self,
2390         expr: &hir::Expr<'_>,
2391         expr_t: Ty<'tcx>,
2392         field: Ident,
2393         base_did: DefId,
2394     ) {
2395         let struct_path = self.tcx().def_path_str(base_did);
2396         let kind_name = self.tcx().def_kind(base_did).descr(base_did);
2397         let mut err = struct_span_err!(
2398             self.tcx().sess,
2399             field.span,
2400             E0616,
2401             "field `{field}` of {kind_name} `{struct_path}` is private",
2402         );
2403         err.span_label(field.span, "private field");
2404         // Also check if an accessible method exists, which is often what is meant.
2405         if self.method_exists(field, expr_t, expr.hir_id, false) && !self.expr_in_place(expr.hir_id)
2406         {
2407             self.suggest_method_call(
2408                 &mut err,
2409                 &format!("a method `{field}` also exists, call it with parentheses"),
2410                 field,
2411                 expr_t,
2412                 expr,
2413                 None,
2414             );
2415         }
2416         err.emit();
2417     }
2418
2419     fn ban_take_value_of_method(&self, expr: &hir::Expr<'_>, expr_t: Ty<'tcx>, field: Ident) {
2420         let mut err = type_error_struct!(
2421             self.tcx().sess,
2422             field.span,
2423             expr_t,
2424             E0615,
2425             "attempted to take value of method `{field}` on type `{expr_t}`",
2426         );
2427         err.span_label(field.span, "method, not a field");
2428         let expr_is_call =
2429             if let hir::Node::Expr(hir::Expr { kind: ExprKind::Call(callee, _args), .. }) =
2430                 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr.hir_id))
2431             {
2432                 expr.hir_id == callee.hir_id
2433             } else {
2434                 false
2435             };
2436         let expr_snippet =
2437             self.tcx.sess.source_map().span_to_snippet(expr.span).unwrap_or_default();
2438         let is_wrapped = expr_snippet.starts_with('(') && expr_snippet.ends_with(')');
2439         let after_open = expr.span.lo() + rustc_span::BytePos(1);
2440         let before_close = expr.span.hi() - rustc_span::BytePos(1);
2441
2442         if expr_is_call && is_wrapped {
2443             err.multipart_suggestion(
2444                 "remove wrapping parentheses to call the method",
2445                 vec![
2446                     (expr.span.with_hi(after_open), String::new()),
2447                     (expr.span.with_lo(before_close), String::new()),
2448                 ],
2449                 Applicability::MachineApplicable,
2450             );
2451         } else if !self.expr_in_place(expr.hir_id) {
2452             // Suggest call parentheses inside the wrapping parentheses
2453             let span = if is_wrapped {
2454                 expr.span.with_lo(after_open).with_hi(before_close)
2455             } else {
2456                 expr.span
2457             };
2458             self.suggest_method_call(
2459                 &mut err,
2460                 "use parentheses to call the method",
2461                 field,
2462                 expr_t,
2463                 expr,
2464                 Some(span),
2465             );
2466         } else if let ty::RawPtr(ty_and_mut) = expr_t.kind()
2467             && let ty::Adt(adt_def, _) = ty_and_mut.ty.kind()
2468             && let ExprKind::Field(base_expr, _) = expr.kind
2469             && adt_def.variants().len() == 1
2470             && adt_def
2471                 .variants()
2472                 .iter()
2473                 .next()
2474                 .unwrap()
2475                 .fields
2476                 .iter()
2477                 .any(|f| f.ident(self.tcx) == field)
2478         {
2479             err.multipart_suggestion(
2480                 "to access the field, dereference first",
2481                 vec![
2482                     (base_expr.span.shrink_to_lo(), "(*".to_string()),
2483                     (base_expr.span.shrink_to_hi(), ")".to_string()),
2484                 ],
2485                 Applicability::MaybeIncorrect,
2486             );
2487         } else {
2488             err.help("methods are immutable and cannot be assigned to");
2489         }
2490
2491         err.emit();
2492     }
2493
2494     fn point_at_param_definition(&self, err: &mut Diagnostic, param: ty::ParamTy) {
2495         let generics = self.tcx.generics_of(self.body_id.owner.to_def_id());
2496         let generic_param = generics.type_param(&param, self.tcx);
2497         if let ty::GenericParamDefKind::Type { synthetic: true, .. } = generic_param.kind {
2498             return;
2499         }
2500         let param_def_id = generic_param.def_id;
2501         let param_hir_id = match param_def_id.as_local() {
2502             Some(x) => self.tcx.hir().local_def_id_to_hir_id(x),
2503             None => return,
2504         };
2505         let param_span = self.tcx.hir().span(param_hir_id);
2506         let param_name = self.tcx.hir().ty_param_name(param_def_id.expect_local());
2507
2508         err.span_label(param_span, &format!("type parameter '{param_name}' declared here"));
2509     }
2510
2511     fn suggest_fields_on_recordish(
2512         &self,
2513         err: &mut Diagnostic,
2514         def: ty::AdtDef<'tcx>,
2515         field: Ident,
2516         access_span: Span,
2517     ) {
2518         if let Some(suggested_field_name) =
2519             self.suggest_field_name(def.non_enum_variant(), field.name, vec![], access_span)
2520         {
2521             err.span_suggestion(
2522                 field.span,
2523                 "a field with a similar name exists",
2524                 suggested_field_name,
2525                 Applicability::MaybeIncorrect,
2526             );
2527         } else {
2528             err.span_label(field.span, "unknown field");
2529             let struct_variant_def = def.non_enum_variant();
2530             let field_names = self.available_field_names(struct_variant_def, access_span);
2531             if !field_names.is_empty() {
2532                 err.note(&format!(
2533                     "available fields are: {}",
2534                     self.name_series_display(field_names),
2535                 ));
2536             }
2537         }
2538     }
2539
2540     fn maybe_suggest_array_indexing(
2541         &self,
2542         err: &mut Diagnostic,
2543         expr: &hir::Expr<'_>,
2544         base: &hir::Expr<'_>,
2545         field: Ident,
2546         len: ty::Const<'tcx>,
2547     ) {
2548         if let (Some(len), Ok(user_index)) =
2549             (len.try_eval_usize(self.tcx, self.param_env), field.as_str().parse::<u64>())
2550             && let Ok(base) = self.tcx.sess.source_map().span_to_snippet(base.span)
2551         {
2552             let help = "instead of using tuple indexing, use array indexing";
2553             let suggestion = format!("{base}[{field}]");
2554             let applicability = if len < user_index {
2555                 Applicability::MachineApplicable
2556             } else {
2557                 Applicability::MaybeIncorrect
2558             };
2559             err.span_suggestion(expr.span, help, suggestion, applicability);
2560         }
2561     }
2562
2563     fn suggest_first_deref_field(
2564         &self,
2565         err: &mut Diagnostic,
2566         expr: &hir::Expr<'_>,
2567         base: &hir::Expr<'_>,
2568         field: Ident,
2569     ) {
2570         if let Ok(base) = self.tcx.sess.source_map().span_to_snippet(base.span) {
2571             let msg = format!("`{base}` is a raw pointer; try dereferencing it");
2572             let suggestion = format!("(*{base}).{field}");
2573             err.span_suggestion(expr.span, &msg, suggestion, Applicability::MaybeIncorrect);
2574         }
2575     }
2576
2577     fn no_such_field_err(
2578         &self,
2579         field: Ident,
2580         expr_t: Ty<'tcx>,
2581         id: HirId,
2582     ) -> DiagnosticBuilder<'_, ErrorGuaranteed> {
2583         let span = field.span;
2584         debug!("no_such_field_err(span: {:?}, field: {:?}, expr_t: {:?})", span, field, expr_t);
2585
2586         let mut err = type_error_struct!(
2587             self.tcx().sess,
2588             field.span,
2589             expr_t,
2590             E0609,
2591             "no field `{field}` on type `{expr_t}`",
2592         );
2593
2594         // try to add a suggestion in case the field is a nested field of a field of the Adt
2595         let mod_id = self.tcx.parent_module(id).to_def_id();
2596         if let Some((fields, substs)) =
2597             self.get_field_candidates_considering_privacy(span, expr_t, mod_id)
2598         {
2599             let candidate_fields: Vec<_> = fields
2600                 .filter_map(|candidate_field| {
2601                     self.check_for_nested_field_satisfying(
2602                         span,
2603                         &|candidate_field, _| candidate_field.ident(self.tcx()) == field,
2604                         candidate_field,
2605                         substs,
2606                         vec![],
2607                         mod_id,
2608                     )
2609                 })
2610                 .map(|mut field_path| {
2611                     field_path.pop();
2612                     field_path
2613                         .iter()
2614                         .map(|id| id.name.to_ident_string())
2615                         .collect::<Vec<String>>()
2616                         .join(".")
2617                 })
2618                 .collect::<Vec<_>>();
2619
2620             let len = candidate_fields.len();
2621             if len > 0 {
2622                 err.span_suggestions(
2623                     field.span.shrink_to_lo(),
2624                     format!(
2625                         "{} of the expressions' fields {} a field of the same name",
2626                         if len > 1 { "some" } else { "one" },
2627                         if len > 1 { "have" } else { "has" },
2628                     ),
2629                     candidate_fields.iter().map(|path| format!("{path}.")),
2630                     Applicability::MaybeIncorrect,
2631                 );
2632             }
2633         }
2634         err
2635     }
2636
2637     pub(crate) fn get_field_candidates_considering_privacy(
2638         &self,
2639         span: Span,
2640         base_ty: Ty<'tcx>,
2641         mod_id: DefId,
2642     ) -> Option<(impl Iterator<Item = &'tcx ty::FieldDef> + 'tcx, SubstsRef<'tcx>)> {
2643         debug!("get_field_candidates(span: {:?}, base_t: {:?}", span, base_ty);
2644
2645         for (base_t, _) in self.autoderef(span, base_ty) {
2646             match base_t.kind() {
2647                 ty::Adt(base_def, substs) if !base_def.is_enum() => {
2648                     let tcx = self.tcx;
2649                     let fields = &base_def.non_enum_variant().fields;
2650                     // Some struct, e.g. some that impl `Deref`, have all private fields
2651                     // because you're expected to deref them to access the _real_ fields.
2652                     // This, for example, will help us suggest accessing a field through a `Box<T>`.
2653                     if fields.iter().all(|field| !field.vis.is_accessible_from(mod_id, tcx)) {
2654                         continue;
2655                     }
2656                     return Some((
2657                         fields
2658                             .iter()
2659                             .filter(move |field| field.vis.is_accessible_from(mod_id, tcx))
2660                             // For compile-time reasons put a limit on number of fields we search
2661                             .take(100),
2662                         substs,
2663                     ));
2664                 }
2665                 _ => {}
2666             }
2667         }
2668         None
2669     }
2670
2671     /// This method is called after we have encountered a missing field error to recursively
2672     /// search for the field
2673     pub(crate) fn check_for_nested_field_satisfying(
2674         &self,
2675         span: Span,
2676         matches: &impl Fn(&ty::FieldDef, Ty<'tcx>) -> bool,
2677         candidate_field: &ty::FieldDef,
2678         subst: SubstsRef<'tcx>,
2679         mut field_path: Vec<Ident>,
2680         mod_id: DefId,
2681     ) -> Option<Vec<Ident>> {
2682         debug!(
2683             "check_for_nested_field_satisfying(span: {:?}, candidate_field: {:?}, field_path: {:?}",
2684             span, candidate_field, field_path
2685         );
2686
2687         if field_path.len() > 3 {
2688             // For compile-time reasons and to avoid infinite recursion we only check for fields
2689             // up to a depth of three
2690             None
2691         } else {
2692             field_path.push(candidate_field.ident(self.tcx).normalize_to_macros_2_0());
2693             let field_ty = candidate_field.ty(self.tcx, subst);
2694             if matches(candidate_field, field_ty) {
2695                 return Some(field_path);
2696             } else if let Some((nested_fields, subst)) =
2697                 self.get_field_candidates_considering_privacy(span, field_ty, mod_id)
2698             {
2699                 // recursively search fields of `candidate_field` if it's a ty::Adt
2700                 for field in nested_fields {
2701                     if let Some(field_path) = self.check_for_nested_field_satisfying(
2702                         span,
2703                         matches,
2704                         field,
2705                         subst,
2706                         field_path.clone(),
2707                         mod_id,
2708                     ) {
2709                         return Some(field_path);
2710                     }
2711                 }
2712             }
2713             None
2714         }
2715     }
2716
2717     fn check_expr_index(
2718         &self,
2719         base: &'tcx hir::Expr<'tcx>,
2720         idx: &'tcx hir::Expr<'tcx>,
2721         expr: &'tcx hir::Expr<'tcx>,
2722     ) -> Ty<'tcx> {
2723         let base_t = self.check_expr(&base);
2724         let idx_t = self.check_expr(&idx);
2725
2726         if base_t.references_error() {
2727             base_t
2728         } else if idx_t.references_error() {
2729             idx_t
2730         } else {
2731             let base_t = self.structurally_resolved_type(base.span, base_t);
2732             match self.lookup_indexing(expr, base, base_t, idx, idx_t) {
2733                 Some((index_ty, element_ty)) => {
2734                     // two-phase not needed because index_ty is never mutable
2735                     self.demand_coerce(idx, idx_t, index_ty, None, AllowTwoPhase::No);
2736                     self.select_obligations_where_possible(|errors| {
2737                         self.point_at_index_if_possible(errors, idx.span)
2738                     });
2739                     element_ty
2740                 }
2741                 None => {
2742                     let mut err = type_error_struct!(
2743                         self.tcx.sess,
2744                         expr.span,
2745                         base_t,
2746                         E0608,
2747                         "cannot index into a value of type `{base_t}`",
2748                     );
2749                     // Try to give some advice about indexing tuples.
2750                     if let ty::Tuple(..) = base_t.kind() {
2751                         let mut needs_note = true;
2752                         // If the index is an integer, we can show the actual
2753                         // fixed expression:
2754                         if let ExprKind::Lit(ref lit) = idx.kind {
2755                             if let ast::LitKind::Int(i, ast::LitIntType::Unsuffixed) = lit.node {
2756                                 let snip = self.tcx.sess.source_map().span_to_snippet(base.span);
2757                                 if let Ok(snip) = snip {
2758                                     err.span_suggestion(
2759                                         expr.span,
2760                                         "to access tuple elements, use",
2761                                         format!("{snip}.{i}"),
2762                                         Applicability::MachineApplicable,
2763                                     );
2764                                     needs_note = false;
2765                                 }
2766                             }
2767                         }
2768                         if needs_note {
2769                             err.help(
2770                                 "to access tuple elements, use tuple indexing \
2771                                         syntax (e.g., `tuple.0`)",
2772                             );
2773                         }
2774                     }
2775                     let reported = err.emit();
2776                     self.tcx.ty_error_with_guaranteed(reported)
2777                 }
2778             }
2779         }
2780     }
2781
2782     fn point_at_index_if_possible(
2783         &self,
2784         errors: &mut Vec<traits::FulfillmentError<'tcx>>,
2785         span: Span,
2786     ) {
2787         for error in errors {
2788             match error.obligation.predicate.kind().skip_binder() {
2789                 ty::PredicateKind::Trait(predicate)
2790                     if self.tcx.is_diagnostic_item(sym::SliceIndex, predicate.trait_ref.def_id) => {
2791                 }
2792                 _ => continue,
2793             }
2794             error.obligation.cause.span = span;
2795         }
2796     }
2797
2798     fn check_expr_yield(
2799         &self,
2800         value: &'tcx hir::Expr<'tcx>,
2801         expr: &'tcx hir::Expr<'tcx>,
2802         src: &'tcx hir::YieldSource,
2803     ) -> Ty<'tcx> {
2804         match self.resume_yield_tys {
2805             Some((resume_ty, yield_ty)) => {
2806                 self.check_expr_coercable_to_type(&value, yield_ty, None);
2807
2808                 resume_ty
2809             }
2810             // Given that this `yield` expression was generated as a result of lowering a `.await`,
2811             // we know that the yield type must be `()`; however, the context won't contain this
2812             // information. Hence, we check the source of the yield expression here and check its
2813             // value's type against `()` (this check should always hold).
2814             None if src.is_await() => {
2815                 self.check_expr_coercable_to_type(&value, self.tcx.mk_unit(), None);
2816                 self.tcx.mk_unit()
2817             }
2818             _ => {
2819                 self.tcx.sess.emit_err(YieldExprOutsideOfGenerator { span: expr.span });
2820                 // Avoid expressions without types during writeback (#78653).
2821                 self.check_expr(value);
2822                 self.tcx.mk_unit()
2823             }
2824         }
2825     }
2826
2827     fn check_expr_asm_operand(&self, expr: &'tcx hir::Expr<'tcx>, is_input: bool) {
2828         let needs = if is_input { Needs::None } else { Needs::MutPlace };
2829         let ty = self.check_expr_with_needs(expr, needs);
2830         self.require_type_is_sized(ty, expr.span, traits::InlineAsmSized);
2831
2832         if !is_input && !expr.is_syntactic_place_expr() {
2833             let mut err = self.tcx.sess.struct_span_err(expr.span, "invalid asm output");
2834             err.span_label(expr.span, "cannot assign to this expression");
2835             err.emit();
2836         }
2837
2838         // If this is an input value, we require its type to be fully resolved
2839         // at this point. This allows us to provide helpful coercions which help
2840         // pass the type candidate list in a later pass.
2841         //
2842         // We don't require output types to be resolved at this point, which
2843         // allows them to be inferred based on how they are used later in the
2844         // function.
2845         if is_input {
2846             let ty = self.structurally_resolved_type(expr.span, ty);
2847             match *ty.kind() {
2848                 ty::FnDef(..) => {
2849                     let fnptr_ty = self.tcx.mk_fn_ptr(ty.fn_sig(self.tcx));
2850                     self.demand_coerce(expr, ty, fnptr_ty, None, AllowTwoPhase::No);
2851                 }
2852                 ty::Ref(_, base_ty, mutbl) => {
2853                     let ptr_ty = self.tcx.mk_ptr(ty::TypeAndMut { ty: base_ty, mutbl });
2854                     self.demand_coerce(expr, ty, ptr_ty, None, AllowTwoPhase::No);
2855                 }
2856                 _ => {}
2857             }
2858         }
2859     }
2860
2861     fn check_expr_asm(&self, asm: &'tcx hir::InlineAsm<'tcx>) -> Ty<'tcx> {
2862         for (op, _op_sp) in asm.operands {
2863             match op {
2864                 hir::InlineAsmOperand::In { expr, .. } => {
2865                     self.check_expr_asm_operand(expr, true);
2866                 }
2867                 hir::InlineAsmOperand::Out { expr: Some(expr), .. }
2868                 | hir::InlineAsmOperand::InOut { expr, .. } => {
2869                     self.check_expr_asm_operand(expr, false);
2870                 }
2871                 hir::InlineAsmOperand::Out { expr: None, .. } => {}
2872                 hir::InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
2873                     self.check_expr_asm_operand(in_expr, true);
2874                     if let Some(out_expr) = out_expr {
2875                         self.check_expr_asm_operand(out_expr, false);
2876                     }
2877                 }
2878                 // `AnonConst`s have their own body and is type-checked separately.
2879                 // As they don't flow into the type system we don't need them to
2880                 // be well-formed.
2881                 hir::InlineAsmOperand::Const { .. } | hir::InlineAsmOperand::SymFn { .. } => {}
2882                 hir::InlineAsmOperand::SymStatic { .. } => {}
2883             }
2884         }
2885         if asm.options.contains(ast::InlineAsmOptions::NORETURN) {
2886             self.tcx.types.never
2887         } else {
2888             self.tcx.mk_unit()
2889         }
2890     }
2891 }