compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs

   1 use crate::astconv::{
   2     AstConv, CreateSubstsForGenericArgsCtxt, ExplicitLateBound, GenericArgCountMismatch,
   3     GenericArgCountResult, IsMethodCall, PathSeg,
   4 };
   5 use crate::check::callee::{self, DeferredCallResolution};
   6 use crate::check::method::{self, MethodCallee, SelfSource};
   7 use crate::check::{BreakableCtxt, Diverges, Expectation, FnCtxt, LocalTy};
   8
   9 use rustc_ast::TraitObjectSyntax;
  10 use rustc_data_structures::captures::Captures;
  11 use rustc_data_structures::fx::FxHashSet;
  12 use rustc_errors::{Applicability, DiagnosticBuilder, ErrorReported};
  13 use rustc_hir as hir;
  14 use rustc_hir::def::{CtorOf, DefKind, Res};
  15 use rustc_hir::def_id::DefId;
  16 use rustc_hir::lang_items::LangItem;
  17 use rustc_hir::{ExprKind, GenericArg, Node, QPath, TyKind};
  18 use rustc_infer::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
  19 use rustc_infer::infer::error_reporting::TypeAnnotationNeeded::E0282;
  20 use rustc_infer::infer::{InferOk, InferResult};
  21 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
  22 use rustc_middle::ty::fold::TypeFoldable;
  23 use rustc_middle::ty::subst::{
  24     self, GenericArgKind, InternalSubsts, Subst, SubstsRef, UserSelfTy, UserSubsts,
  25 };
  26 use rustc_middle::ty::{
  27     self, AdtKind, CanonicalUserType, DefIdTree, GenericParamDefKind, ToPolyTraitRef, ToPredicate,
  28     Ty, UserType,
  29 };
  30 use rustc_session::lint;
  31 use rustc_session::lint::builtin::BARE_TRAIT_OBJECTS;
  32 use rustc_span::edition::Edition;
  33 use rustc_span::hygiene::DesugaringKind;
  34 use rustc_span::source_map::{original_sp, DUMMY_SP};
  35 use rustc_span::symbol::{kw, sym, Ident};
  36 use rustc_span::{self, BytePos, MultiSpan, Span};
  37 use rustc_trait_selection::infer::InferCtxtExt as _;
  38 use rustc_trait_selection::traits::error_reporting::InferCtxtExt as _;
  39 use rustc_trait_selection::traits::{
  40     self, ObligationCause, ObligationCauseCode, StatementAsExpression, TraitEngine, TraitEngineExt,
  41     WellFormedLoc,
  42 };
  43
  44 use std::collections::hash_map::Entry;
  45 use std::iter;
  46 use std::slice;
  47
  48 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  49     /// Produces warning on the given node, if the current point in the
  50     /// function is unreachable, and there hasn't been another warning.
  51     pub(in super::super) fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
  52         // FIXME: Combine these two 'if' expressions into one once
  53         // let chains are implemented
  54         if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
  55             // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
  56             // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
  57             // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
  58             if !span.is_desugaring(DesugaringKind::CondTemporary)
  59                 && !span.is_desugaring(DesugaringKind::Async)
  60                 && !orig_span.is_desugaring(DesugaringKind::Await)
  61             {
  62                 self.diverges.set(Diverges::WarnedAlways);
  63
  64                 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
  65
  66                 self.tcx().struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, |lint| {
  67                     let msg = format!("unreachable {}", kind);
  68                     lint.build(&msg)
  69                         .span_label(span, &msg)
  70                         .span_label(
  71                             orig_span,
  72                             custom_note
  73                                 .unwrap_or("any code following this expression is unreachable"),
  74                         )
  75                         .emit();
  76                 })
  77             }
  78         }
  79     }
  80
  81     /// Resolves type and const variables in `ty` if possible. Unlike the infcx
  82     /// version (resolve_vars_if_possible), this version will
  83     /// also select obligations if it seems useful, in an effort
  84     /// to get more type information.
  85     pub(in super::super) fn resolve_vars_with_obligations(&self, ty: Ty<'tcx>) -> Ty<'tcx> {
  86         self.resolve_vars_with_obligations_and_mutate_fulfillment(ty, |_| {})
  87     }
  88
  89     #[instrument(skip(self, mutate_fulfillment_errors), level = "debug")]
  90     pub(in super::super) fn resolve_vars_with_obligations_and_mutate_fulfillment(
  91         &self,
  92         mut ty: Ty<'tcx>,
  93         mutate_fulfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
  94     ) -> Ty<'tcx> {
  95         // No Infer()? Nothing needs doing.
  96         if !ty.has_infer_types_or_consts() {
  97             debug!("no inference var, nothing needs doing");
  98             return ty;
  99         }
 100
 101         // If `ty` is a type variable, see whether we already know what it is.
 102         ty = self.resolve_vars_if_possible(ty);
 103         if !ty.has_infer_types_or_consts() {
 104             debug!(?ty);
 105             return ty;
 106         }
 107
 108         // If not, try resolving pending obligations as much as
 109         // possible. This can help substantially when there are
 110         // indirect dependencies that don't seem worth tracking
 111         // precisely.
 112         self.select_obligations_where_possible(false, mutate_fulfillment_errors);
 113         ty = self.resolve_vars_if_possible(ty);
 114
 115         debug!(?ty);
 116         ty
 117     }
 118
 119     pub(in super::super) fn record_deferred_call_resolution(
 120         &self,
 121         closure_def_id: DefId,
 122         r: DeferredCallResolution<'tcx>,
 123     ) {
 124         let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
 125         deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
 126     }
 127
 128     pub(in super::super) fn remove_deferred_call_resolutions(
 129         &self,
 130         closure_def_id: DefId,
 131     ) -> Vec<DeferredCallResolution<'tcx>> {
 132         let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
 133         deferred_call_resolutions.remove(&closure_def_id).unwrap_or_default()
 134     }
 135
 136     pub fn tag(&self) -> String {
 137         format!("{:p}", self)
 138     }
 139
 140     pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
 141         self.locals.borrow().get(&nid).cloned().unwrap_or_else(|| {
 142             span_bug!(span, "no type for local variable {}", self.tcx.hir().node_to_string(nid))
 143         })
 144     }
 145
 146     #[inline]
 147     pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
 148         debug!("write_ty({:?}, {:?}) in fcx {}", id, self.resolve_vars_if_possible(ty), self.tag());
 149         self.typeck_results.borrow_mut().node_types_mut().insert(id, ty);
 150
 151         if ty.references_error() {
 152             self.has_errors.set(true);
 153             self.set_tainted_by_errors();
 154         }
 155     }
 156
 157     pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
 158         self.typeck_results.borrow_mut().field_indices_mut().insert(hir_id, index);
 159     }
 160
 161     pub(in super::super) fn write_resolution(
 162         &self,
 163         hir_id: hir::HirId,
 164         r: Result<(DefKind, DefId), ErrorReported>,
 165     ) {
 166         self.typeck_results.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
 167     }
 168
 169     pub fn write_method_call(&self, hir_id: hir::HirId, method: MethodCallee<'tcx>) {
 170         debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
 171         self.write_resolution(hir_id, Ok((DefKind::AssocFn, method.def_id)));
 172         self.write_substs(hir_id, method.substs);
 173
 174         // When the method is confirmed, the `method.substs` includes
 175         // parameters from not just the method, but also the impl of
 176         // the method -- in particular, the `Self` type will be fully
 177         // resolved. However, those are not something that the "user
 178         // specified" -- i.e., those types come from the inferred type
 179         // of the receiver, not something the user wrote. So when we
 180         // create the user-substs, we want to replace those earlier
 181         // types with just the types that the user actually wrote --
 182         // that is, those that appear on the *method itself*.
 183         //
 184         // As an example, if the user wrote something like
 185         // `foo.bar::<u32>(...)` -- the `Self` type here will be the
 186         // type of `foo` (possibly adjusted), but we don't want to
 187         // include that. We want just the `[_, u32]` part.
 188         if !method.substs.is_noop() {
 189             let method_generics = self.tcx.generics_of(method.def_id);
 190             if !method_generics.params.is_empty() {
 191                 let user_type_annotation = self.infcx.probe(|_| {
 192                     let user_substs = UserSubsts {
 193                         substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
 194                             let i = param.index as usize;
 195                             if i < method_generics.parent_count {
 196                                 self.infcx.var_for_def(DUMMY_SP, param)
 197                             } else {
 198                                 method.substs[i]
 199                             }
 200                         }),
 201                         user_self_ty: None, // not relevant here
 202                     };
 203
 204                     self.infcx.canonicalize_user_type_annotation(UserType::TypeOf(
 205                         method.def_id,
 206                         user_substs,
 207                     ))
 208                 });
 209
 210                 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
 211                 self.write_user_type_annotation(hir_id, user_type_annotation);
 212             }
 213         }
 214     }
 215
 216     pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
 217         if !substs.is_noop() {
 218             debug!("write_substs({:?}, {:?}) in fcx {}", node_id, substs, self.tag());
 219
 220             self.typeck_results.borrow_mut().node_substs_mut().insert(node_id, substs);
 221         }
 222     }
 223
 224     /// Given the substs that we just converted from the HIR, try to
 225     /// canonicalize them and store them as user-given substitutions
 226     /// (i.e., substitutions that must be respected by the NLL check).
 227     ///
 228     /// This should be invoked **before any unifications have
 229     /// occurred**, so that annotations like `Vec<_>` are preserved
 230     /// properly.
 231     #[instrument(skip(self), level = "debug")]
 232     pub fn write_user_type_annotation_from_substs(
 233         &self,
 234         hir_id: hir::HirId,
 235         def_id: DefId,
 236         substs: SubstsRef<'tcx>,
 237         user_self_ty: Option<UserSelfTy<'tcx>>,
 238     ) {
 239         debug!("fcx {}", self.tag());
 240
 241         if self.can_contain_user_lifetime_bounds((substs, user_self_ty)) {
 242             let canonicalized = self.infcx.canonicalize_user_type_annotation(UserType::TypeOf(
 243                 def_id,
 244                 UserSubsts { substs, user_self_ty },
 245             ));
 246             debug!(?canonicalized);
 247             self.write_user_type_annotation(hir_id, canonicalized);
 248         }
 249     }
 250
 251     #[instrument(skip(self), level = "debug")]
 252     pub fn write_user_type_annotation(
 253         &self,
 254         hir_id: hir::HirId,
 255         canonical_user_type_annotation: CanonicalUserType<'tcx>,
 256     ) {
 257         debug!("fcx {}", self.tag());
 258
 259         if !canonical_user_type_annotation.is_identity() {
 260             self.typeck_results
 261                 .borrow_mut()
 262                 .user_provided_types_mut()
 263                 .insert(hir_id, canonical_user_type_annotation);
 264         } else {
 265             debug!("skipping identity substs");
 266         }
 267     }
 268
 269     #[instrument(skip(self, expr), level = "debug")]
 270     pub fn apply_adjustments(&self, expr: &hir::Expr<'_>, adj: Vec<Adjustment<'tcx>>) {
 271         debug!("expr = {:#?}", expr);
 272
 273         if adj.is_empty() {
 274             return;
 275         }
 276
 277         for a in &adj {
 278             if let Adjust::NeverToAny = a.kind {
 279                 if a.target.is_ty_var() {
 280                     self.diverging_type_vars.borrow_mut().insert(a.target);
 281                     debug!("apply_adjustments: adding `{:?}` as diverging type var", a.target);
 282                 }
 283             }
 284         }
 285
 286         let autoborrow_mut = adj.iter().any(|adj| {
 287             matches!(
 288                 adj,
 289                 &Adjustment {
 290                     kind: Adjust::Borrow(AutoBorrow::Ref(_, AutoBorrowMutability::Mut { .. })),
 291                     ..
 292                 }
 293             )
 294         });
 295
 296         match self.typeck_results.borrow_mut().adjustments_mut().entry(expr.hir_id) {
 297             Entry::Vacant(entry) => {
 298                 entry.insert(adj);
 299             }
 300             Entry::Occupied(mut entry) => {
 301                 debug!(" - composing on top of {:?}", entry.get());
 302                 match (&entry.get()[..], &adj[..]) {
 303                     // Applying any adjustment on top of a NeverToAny
 304                     // is a valid NeverToAny adjustment, because it can't
 305                     // be reached.
 306                     (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
 307                     (&[
 308                         Adjustment { kind: Adjust::Deref(_), .. },
 309                         Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
 310                     ], &[
 311                         Adjustment { kind: Adjust::Deref(_), .. },
 312                         .. // Any following adjustments are allowed.
 313                     ]) => {
 314                         // A reborrow has no effect before a dereference.
 315                     }
 316                     // FIXME: currently we never try to compose autoderefs
 317                     // and ReifyFnPointer/UnsafeFnPointer, but we could.
 318                     _ =>
 319                         bug!("while adjusting {:?}, can't compose {:?} and {:?}",
 320                              expr, entry.get(), adj)
 321                 };
 322                 *entry.get_mut() = adj;
 323             }
 324         }
 325
 326         // If there is an mutable auto-borrow, it is equivalent to `&mut <expr>`.
 327         // In this case implicit use of `Deref` and `Index` within `<expr>` should
 328         // instead be `DerefMut` and `IndexMut`, so fix those up.
 329         if autoborrow_mut {
 330             self.convert_place_derefs_to_mutable(expr);
 331         }
 332     }
 333
 334     /// Basically whenever we are converting from a type scheme into
 335     /// the fn body space, we always want to normalize associated
 336     /// types as well. This function combines the two.
 337     fn instantiate_type_scheme<T>(&self, span: Span, substs: SubstsRef<'tcx>, value: T) -> T
 338     where
 339         T: TypeFoldable<'tcx>,
 340     {
 341         debug!("instantiate_type_scheme(value={:?}, substs={:?})", value, substs);
 342         let value = value.subst(self.tcx, substs);
 343         let result = self.normalize_associated_types_in(span, value);
 344         debug!("instantiate_type_scheme = {:?}", result);
 345         result
 346     }
 347
 348     /// As `instantiate_type_scheme`, but for the bounds found in a
 349     /// generic type scheme.
 350     pub(in super::super) fn instantiate_bounds(
 351         &self,
 352         span: Span,
 353         def_id: DefId,
 354         substs: SubstsRef<'tcx>,
 355     ) -> (ty::InstantiatedPredicates<'tcx>, Vec<Span>) {
 356         let bounds = self.tcx.predicates_of(def_id);
 357         let spans: Vec<Span> = bounds.predicates.iter().map(|(_, span)| *span).collect();
 358         let result = bounds.instantiate(self.tcx, substs);
 359         let result = self.normalize_associated_types_in(span, result);
 360         debug!(
 361             "instantiate_bounds(bounds={:?}, substs={:?}) = {:?}, {:?}",
 362             bounds, substs, result, spans,
 363         );
 364         (result, spans)
 365     }
 366
 367     /// Replaces the opaque types from the given value with type variables,
 368     /// and records the `OpaqueTypeMap` for later use during writeback. See
 369     /// `InferCtxt::instantiate_opaque_types` for more details.
 370     #[instrument(skip(self, value_span), level = "debug")]
 371     pub(in super::super) fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
 372         &self,
 373         value: T,
 374         value_span: Span,
 375     ) -> T {
 376         self.register_infer_ok_obligations(self.instantiate_opaque_types(
 377             self.body_id,
 378             self.param_env,
 379             value,
 380             value_span,
 381         ))
 382     }
 383
 384     /// Convenience method which tracks extra diagnostic information for normalization
 385     /// that occurs as a result of WF checking. The `hir_id` is the `HirId` of the hir item
 386     /// whose type is being wf-checked - this is used to construct a more precise span if
 387     /// an error occurs.
 388     ///
 389     /// It is never necessary to call this method - calling `normalize_associated_types_in` will
 390     /// just result in a slightly worse diagnostic span, and will still be sound.
 391     pub(in super::super) fn normalize_associated_types_in_wf<T>(
 392         &self,
 393         span: Span,
 394         value: T,
 395         loc: WellFormedLoc,
 396     ) -> T
 397     where
 398         T: TypeFoldable<'tcx>,
 399     {
 400         self.inh.normalize_associated_types_in_with_cause(
 401             ObligationCause::new(span, self.body_id, ObligationCauseCode::WellFormed(Some(loc))),
 402             self.param_env,
 403             value,
 404         )
 405     }
 406
 407     pub(in super::super) fn normalize_associated_types_in<T>(&self, span: Span, value: T) -> T
 408     where
 409         T: TypeFoldable<'tcx>,
 410     {
 411         self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
 412     }
 413
 414     pub(in super::super) fn normalize_associated_types_in_as_infer_ok<T>(
 415         &self,
 416         span: Span,
 417         value: T,
 418     ) -> InferOk<'tcx, T>
 419     where
 420         T: TypeFoldable<'tcx>,
 421     {
 422         self.inh.partially_normalize_associated_types_in(
 423             ObligationCause::misc(span, self.body_id),
 424             self.param_env,
 425             value,
 426         )
 427     }
 428
 429     pub fn require_type_meets(
 430         &self,
 431         ty: Ty<'tcx>,
 432         span: Span,
 433         code: traits::ObligationCauseCode<'tcx>,
 434         def_id: DefId,
 435     ) {
 436         self.register_bound(ty, def_id, traits::ObligationCause::new(span, self.body_id, code));
 437     }
 438
 439     pub fn require_type_is_sized(
 440         &self,
 441         ty: Ty<'tcx>,
 442         span: Span,
 443         code: traits::ObligationCauseCode<'tcx>,
 444     ) {
 445         if !ty.references_error() {
 446             let lang_item = self.tcx.require_lang_item(LangItem::Sized, None);
 447             self.require_type_meets(ty, span, code, lang_item);
 448         }
 449     }
 450
 451     pub fn require_type_is_sized_deferred(
 452         &self,
 453         ty: Ty<'tcx>,
 454         span: Span,
 455         code: traits::ObligationCauseCode<'tcx>,
 456     ) {
 457         if !ty.references_error() {
 458             self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
 459         }
 460     }
 461
 462     pub fn register_bound(
 463         &self,
 464         ty: Ty<'tcx>,
 465         def_id: DefId,
 466         cause: traits::ObligationCause<'tcx>,
 467     ) {
 468         if !ty.references_error() {
 469             self.fulfillment_cx.borrow_mut().register_bound(
 470                 self,
 471                 self.param_env,
 472                 ty,
 473                 def_id,
 474                 cause,
 475             );
 476         }
 477     }
 478
 479     pub fn to_ty(&self, ast_t: &hir::Ty<'_>) -> Ty<'tcx> {
 480         let t = <dyn AstConv<'_>>::ast_ty_to_ty(self, ast_t);
 481         self.register_wf_obligation(t.into(), ast_t.span, traits::MiscObligation);
 482         t
 483     }
 484
 485     pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty<'_>) -> Ty<'tcx> {
 486         let ty = self.to_ty(ast_ty);
 487         debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
 488
 489         if self.can_contain_user_lifetime_bounds(ty) {
 490             let c_ty = self.infcx.canonicalize_response(UserType::Ty(ty));
 491             debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
 492             self.typeck_results.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
 493         }
 494
 495         ty
 496     }
 497
 498     pub fn to_const(&self, ast_c: &hir::AnonConst) -> &'tcx ty::Const<'tcx> {
 499         let const_def_id = self.tcx.hir().local_def_id(ast_c.hir_id);
 500         let c = ty::Const::from_anon_const(self.tcx, const_def_id);
 501         self.register_wf_obligation(
 502             c.into(),
 503             self.tcx.hir().span(ast_c.hir_id),
 504             ObligationCauseCode::MiscObligation,
 505         );
 506         c
 507     }
 508
 509     pub fn const_arg_to_const(
 510         &self,
 511         ast_c: &hir::AnonConst,
 512         param_def_id: DefId,
 513     ) -> &'tcx ty::Const<'tcx> {
 514         let const_def = ty::WithOptConstParam {
 515             did: self.tcx.hir().local_def_id(ast_c.hir_id),
 516             const_param_did: Some(param_def_id),
 517         };
 518         let c = ty::Const::from_opt_const_arg_anon_const(self.tcx, const_def);
 519         self.register_wf_obligation(
 520             c.into(),
 521             self.tcx.hir().span(ast_c.hir_id),
 522             ObligationCauseCode::MiscObligation,
 523         );
 524         c
 525     }
 526
 527     // If the type given by the user has free regions, save it for later, since
 528     // NLL would like to enforce those. Also pass in types that involve
 529     // projections, since those can resolve to `'static` bounds (modulo #54940,
 530     // which hopefully will be fixed by the time you see this comment, dear
 531     // reader, although I have my doubts). Also pass in types with inference
 532     // types, because they may be repeated. Other sorts of things are already
 533     // sufficiently enforced with erased regions. =)
 534     fn can_contain_user_lifetime_bounds<T>(&self, t: T) -> bool
 535     where
 536         T: TypeFoldable<'tcx>,
 537     {
 538         t.has_free_regions(self.tcx) || t.has_projections() || t.has_infer_types()
 539     }
 540
 541     pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
 542         match self.typeck_results.borrow().node_types().get(id) {
 543             Some(&t) => t,
 544             None if self.is_tainted_by_errors() => self.tcx.ty_error(),
 545             None => {
 546                 bug!(
 547                     "no type for node {}: {} in fcx {}",
 548                     id,
 549                     self.tcx.hir().node_to_string(id),
 550                     self.tag()
 551                 );
 552             }
 553         }
 554     }
 555
 556     pub fn node_ty_opt(&self, id: hir::HirId) -> Option<Ty<'tcx>> {
 557         match self.typeck_results.borrow().node_types().get(id) {
 558             Some(&t) => Some(t),
 559             None if self.is_tainted_by_errors() => Some(self.tcx.ty_error()),
 560             None => None,
 561         }
 562     }
 563
 564     /// Registers an obligation for checking later, during regionck, that `arg` is well-formed.
 565     pub fn register_wf_obligation(
 566         &self,
 567         arg: subst::GenericArg<'tcx>,
 568         span: Span,
 569         code: traits::ObligationCauseCode<'tcx>,
 570     ) {
 571         // WF obligations never themselves fail, so no real need to give a detailed cause:
 572         let cause = traits::ObligationCause::new(span, self.body_id, code);
 573         self.register_predicate(traits::Obligation::new(
 574             cause,
 575             self.param_env,
 576             ty::Binder::dummy(ty::PredicateKind::WellFormed(arg)).to_predicate(self.tcx),
 577         ));
 578     }
 579
 580     /// Registers obligations that all `substs` are well-formed.
 581     pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr<'_>) {
 582         for arg in substs.iter().filter(|arg| {
 583             matches!(arg.unpack(), GenericArgKind::Type(..) | GenericArgKind::Const(..))
 584         }) {
 585             self.register_wf_obligation(arg, expr.span, traits::MiscObligation);
 586         }
 587     }
 588
 589     /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
 590     /// type/region parameter was instantiated (`substs`), creates and registers suitable
 591     /// trait/region obligations.
 592     ///
 593     /// For example, if there is a function:
 594     ///
 595     /// ```
 596     /// fn foo<'a,T:'a>(...)
 597     /// ```
 598     ///
 599     /// and a reference:
 600     ///
 601     /// ```
 602     /// let f = foo;
 603     /// ```
 604     ///
 605     /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
 606     /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
 607     pub fn add_obligations_for_parameters(
 608         &self,
 609         cause: traits::ObligationCause<'tcx>,
 610         predicates: ty::InstantiatedPredicates<'tcx>,
 611     ) {
 612         assert!(!predicates.has_escaping_bound_vars());
 613
 614         debug!("add_obligations_for_parameters(predicates={:?})", predicates);
 615
 616         for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
 617             self.register_predicate(obligation);
 618         }
 619     }
 620
 621     // FIXME(arielb1): use this instead of field.ty everywhere
 622     // Only for fields! Returns <none> for methods>
 623     // Indifferent to privacy flags
 624     pub fn field_ty(
 625         &self,
 626         span: Span,
 627         field: &'tcx ty::FieldDef,
 628         substs: SubstsRef<'tcx>,
 629     ) -> Ty<'tcx> {
 630         self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
 631     }
 632
 633     pub(in super::super) fn resolve_generator_interiors(&self, def_id: DefId) {
 634         let mut generators = self.deferred_generator_interiors.borrow_mut();
 635         for (body_id, interior, kind) in generators.drain(..) {
 636             self.select_obligations_where_possible(false, |_| {});
 637             crate::check::generator_interior::resolve_interior(
 638                 self, def_id, body_id, interior, kind,
 639             );
 640         }
 641     }
 642
 643     #[instrument(skip(self), level = "debug")]
 644     pub(in super::super) fn select_all_obligations_or_error(&self) {
 645         let errors = self
 646             .fulfillment_cx
 647             .borrow_mut()
 648             .select_all_with_constness_or_error(&self, self.inh.constness);
 649
 650         if !errors.is_empty() {
 651             self.report_fulfillment_errors(&errors, self.inh.body_id, false);
 652         }
 653     }
 654
 655     /// Select as many obligations as we can at present.
 656     pub(in super::super) fn select_obligations_where_possible(
 657         &self,
 658         fallback_has_occurred: bool,
 659         mutate_fulfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
 660     ) {
 661         let mut result = self
 662             .fulfillment_cx
 663             .borrow_mut()
 664             .select_with_constness_where_possible(self, self.inh.constness);
 665         if !result.is_empty() {
 666             mutate_fulfillment_errors(&mut result);
 667             self.report_fulfillment_errors(&result, self.inh.body_id, fallback_has_occurred);
 668         }
 669     }
 670
 671     /// For the overloaded place expressions (`*x`, `x[3]`), the trait
 672     /// returns a type of `&T`, but the actual type we assign to the
 673     /// *expression* is `T`. So this function just peels off the return
 674     /// type by one layer to yield `T`.
 675     pub(in super::super) fn make_overloaded_place_return_type(
 676         &self,
 677         method: MethodCallee<'tcx>,
 678     ) -> ty::TypeAndMut<'tcx> {
 679         // extract method return type, which will be &T;
 680         let ret_ty = method.sig.output();
 681
 682         // method returns &T, but the type as visible to user is T, so deref
 683         ret_ty.builtin_deref(true).unwrap()
 684     }
 685
 686     #[instrument(skip(self), level = "debug")]
 687     fn self_type_matches_expected_vid(
 688         &self,
 689         trait_ref: ty::PolyTraitRef<'tcx>,
 690         expected_vid: ty::TyVid,
 691     ) -> bool {
 692         let self_ty = self.shallow_resolve(trait_ref.skip_binder().self_ty());
 693         debug!(?self_ty);
 694
 695         match *self_ty.kind() {
 696             ty::Infer(ty::TyVar(found_vid)) => {
 697                 // FIXME: consider using `sub_root_var` here so we
 698                 // can see through subtyping.
 699                 let found_vid = self.root_var(found_vid);
 700                 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
 701                 expected_vid == found_vid
 702             }
 703             _ => false,
 704         }
 705     }
 706
 707     #[instrument(skip(self), level = "debug")]
 708     pub(in super::super) fn obligations_for_self_ty<'b>(
 709         &'b self,
 710         self_ty: ty::TyVid,
 711     ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
 712     + Captures<'tcx>
 713     + 'b {
 714         // FIXME: consider using `sub_root_var` here so we
 715         // can see through subtyping.
 716         let ty_var_root = self.root_var(self_ty);
 717         trace!("pending_obligations = {:#?}", self.fulfillment_cx.borrow().pending_obligations());
 718
 719         self.fulfillment_cx
 720             .borrow()
 721             .pending_obligations()
 722             .into_iter()
 723             .filter_map(move |obligation| {
 724                 let bound_predicate = obligation.predicate.kind();
 725                 match bound_predicate.skip_binder() {
 726                     ty::PredicateKind::Projection(data) => Some((
 727                         bound_predicate.rebind(data).required_poly_trait_ref(self.tcx),
 728                         obligation,
 729                     )),
 730                     ty::PredicateKind::Trait(data) => {
 731                         Some((bound_predicate.rebind(data).to_poly_trait_ref(), obligation))
 732                     }
 733                     ty::PredicateKind::Subtype(..) => None,
 734                     ty::PredicateKind::Coerce(..) => None,
 735                     ty::PredicateKind::RegionOutlives(..) => None,
 736                     ty::PredicateKind::TypeOutlives(..) => None,
 737                     ty::PredicateKind::WellFormed(..) => None,
 738                     ty::PredicateKind::ObjectSafe(..) => None,
 739                     ty::PredicateKind::ConstEvaluatable(..) => None,
 740                     ty::PredicateKind::ConstEquate(..) => None,
 741                     // N.B., this predicate is created by breaking down a
 742                     // `ClosureType: FnFoo()` predicate, where
 743                     // `ClosureType` represents some `Closure`. It can't
 744                     // possibly be referring to the current closure,
 745                     // because we haven't produced the `Closure` for
 746                     // this closure yet; this is exactly why the other
 747                     // code is looking for a self type of an unresolved
 748                     // inference variable.
 749                     ty::PredicateKind::ClosureKind(..) => None,
 750                     ty::PredicateKind::TypeWellFormedFromEnv(..) => None,
 751                 }
 752             })
 753             .filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
 754     }
 755
 756     pub(in super::super) fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
 757         self.obligations_for_self_ty(self_ty)
 758             .any(|(tr, _)| Some(tr.def_id()) == self.tcx.lang_items().sized_trait())
 759     }
 760
 761     pub(in super::super) fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
 762         vec![self.tcx.ty_error(); len]
 763     }
 764
 765     /// Unifies the output type with the expected type early, for more coercions
 766     /// and forward type information on the input expressions.
 767     #[instrument(skip(self, call_span), level = "debug")]
 768     pub(in super::super) fn expected_inputs_for_expected_output(
 769         &self,
 770         call_span: Span,
 771         expected_ret: Expectation<'tcx>,
 772         formal_ret: Ty<'tcx>,
 773         formal_args: &[Ty<'tcx>],
 774     ) -> Vec<Ty<'tcx>> {
 775         let formal_ret = self.resolve_vars_with_obligations(formal_ret);
 776         let ret_ty = match expected_ret.only_has_type(self) {
 777             Some(ret) => ret,
 778             None => return Vec::new(),
 779         };
 780         let expect_args = self
 781             .fudge_inference_if_ok(|| {
 782                 // Attempt to apply a subtyping relationship between the formal
 783                 // return type (likely containing type variables if the function
 784                 // is polymorphic) and the expected return type.
 785                 // No argument expectations are produced if unification fails.
 786                 let origin = self.misc(call_span);
 787                 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
 788
 789                 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
 790                 // to identity so the resulting type is not constrained.
 791                 match ures {
 792                     Ok(ok) => {
 793                         // Process any obligations locally as much as
 794                         // we can.  We don't care if some things turn
 795                         // out unconstrained or ambiguous, as we're
 796                         // just trying to get hints here.
 797                         let errors = self.save_and_restore_in_snapshot_flag(|_| {
 798                             let mut fulfill = <dyn TraitEngine<'_>>::new(self.tcx);
 799                             for obligation in ok.obligations {
 800                                 fulfill.register_predicate_obligation(self, obligation);
 801                             }
 802                             fulfill.select_where_possible(self)
 803                         });
 804
 805                         if !errors.is_empty() {
 806                             return Err(());
 807                         }
 808                     }
 809                     Err(_) => return Err(()),
 810                 }
 811
 812                 // Record all the argument types, with the substitutions
 813                 // produced from the above subtyping unification.
 814                 Ok(formal_args.iter().map(|&ty| self.resolve_vars_if_possible(ty)).collect())
 815             })
 816             .unwrap_or_default();
 817         debug!(?formal_args, ?formal_ret, ?expect_args, ?expected_ret);
 818         expect_args
 819     }
 820
 821     pub(in super::super) fn resolve_lang_item_path(
 822         &self,
 823         lang_item: hir::LangItem,
 824         span: Span,
 825         hir_id: hir::HirId,
 826     ) -> (Res, Ty<'tcx>) {
 827         let def_id = self.tcx.require_lang_item(lang_item, Some(span));
 828         let def_kind = self.tcx.def_kind(def_id);
 829
 830         let item_ty = if let DefKind::Variant = def_kind {
 831             self.tcx.type_of(self.tcx.parent(def_id).expect("variant w/out parent"))
 832         } else {
 833             self.tcx.type_of(def_id)
 834         };
 835         let substs = self.infcx.fresh_substs_for_item(span, def_id);
 836         let ty = item_ty.subst(self.tcx, substs);
 837
 838         self.write_resolution(hir_id, Ok((def_kind, def_id)));
 839         self.add_required_obligations(span, def_id, &substs);
 840         (Res::Def(def_kind, def_id), ty)
 841     }
 842
 843     /// Resolves an associated value path into a base type and associated constant, or method
 844     /// resolution. The newly resolved definition is written into `type_dependent_defs`.
 845     pub fn resolve_ty_and_res_fully_qualified_call(
 846         &self,
 847         qpath: &'tcx QPath<'tcx>,
 848         hir_id: hir::HirId,
 849         span: Span,
 850     ) -> (Res, Option<Ty<'tcx>>, &'tcx [hir::PathSegment<'tcx>]) {
 851         debug!(
 852             "resolve_ty_and_res_fully_qualified_call: qpath={:?} hir_id={:?} span={:?}",
 853             qpath, hir_id, span
 854         );
 855         let (ty, qself, item_segment) = match *qpath {
 856             QPath::Resolved(ref opt_qself, ref path) => {
 857                 return (
 858                     path.res,
 859                     opt_qself.as_ref().map(|qself| self.to_ty(qself)),
 860                     path.segments,
 861                 );
 862             }
 863             QPath::TypeRelative(ref qself, ref segment) => {
 864                 // Don't use `self.to_ty`, since this will register a WF obligation.
 865                 // If we're trying to call a non-existent method on a trait
 866                 // (e.g. `MyTrait::missing_method`), then resolution will
 867                 // give us a `QPath::TypeRelative` with a trait object as
 868                 // `qself`. In that case, we want to avoid registering a WF obligation
 869                 // for `dyn MyTrait`, since we don't actually need the trait
 870                 // to be object-safe.
 871                 // We manually call `register_wf_obligation` in the success path
 872                 // below.
 873                 (<dyn AstConv<'_>>::ast_ty_to_ty(self, qself), qself, segment)
 874             }
 875             QPath::LangItem(..) => {
 876                 bug!("`resolve_ty_and_res_fully_qualified_call` called on `LangItem`")
 877             }
 878         };
 879         if let Some(&cached_result) = self.typeck_results.borrow().type_dependent_defs().get(hir_id)
 880         {
 881             self.register_wf_obligation(ty.into(), qself.span, traits::WellFormed(None));
 882             // Return directly on cache hit. This is useful to avoid doubly reporting
 883             // errors with default match binding modes. See #44614.
 884             let def = cached_result.map_or(Res::Err, |(kind, def_id)| Res::Def(kind, def_id));
 885             return (def, Some(ty), slice::from_ref(&**item_segment));
 886         }
 887         let item_name = item_segment.ident;
 888         let result = self
 889             .resolve_fully_qualified_call(span, item_name, ty, qself.span, hir_id)
 890             .or_else(|error| {
 891                 let result = match error {
 892                     method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
 893                     _ => Err(ErrorReported),
 894                 };
 895
 896                 // If we have a path like `MyTrait::missing_method`, then don't register
 897                 // a WF obligation for `dyn MyTrait` when method lookup fails. Otherwise,
 898                 // register a WF obligation so that we can detect any additional
 899                 // errors in the self type.
 900                 if !(matches!(error, method::MethodError::NoMatch(_)) && ty.is_trait()) {
 901                     self.register_wf_obligation(ty.into(), qself.span, traits::WellFormed(None));
 902                 }
 903                 if item_name.name != kw::Empty {
 904                     if let Some(mut e) = self.report_method_error(
 905                         span,
 906                         ty,
 907                         item_name,
 908                         SelfSource::QPath(qself),
 909                         error,
 910                         None,
 911                     ) {
 912                         e.emit();
 913                     }
 914                 }
 915                 result
 916             });
 917
 918         if result.is_ok() {
 919             self.maybe_lint_bare_trait(qpath, hir_id, span);
 920             self.register_wf_obligation(ty.into(), qself.span, traits::WellFormed(None));
 921         }
 922
 923         // Write back the new resolution.
 924         self.write_resolution(hir_id, result);
 925         (
 926             result.map_or(Res::Err, |(kind, def_id)| Res::Def(kind, def_id)),
 927             Some(ty),
 928             slice::from_ref(&**item_segment),
 929         )
 930     }
 931
 932     fn maybe_lint_bare_trait(&self, qpath: &QPath<'_>, hir_id: hir::HirId, span: Span) {
 933         if let QPath::TypeRelative(self_ty, _) = qpath {
 934             if let TyKind::TraitObject([poly_trait_ref, ..], _, TraitObjectSyntax::None) =
 935                 self_ty.kind
 936             {
 937                 let msg = "trait objects without an explicit `dyn` are deprecated";
 938                 let (sugg, app) = match self.tcx.sess.source_map().span_to_snippet(self_ty.span) {
 939                     Ok(s) if poly_trait_ref.trait_ref.path.is_global() => {
 940                         (format!("dyn ({})", s), Applicability::MachineApplicable)
 941                     }
 942                     Ok(s) => (format!("dyn {}", s), Applicability::MachineApplicable),
 943                     Err(_) => ("dyn <type>".to_string(), Applicability::HasPlaceholders),
 944                 };
 945                 // Wrap in `<..>` if it isn't already.
 946                 let sugg = match self.tcx.sess.source_map().span_to_snippet(span) {
 947                     Ok(s) if s.starts_with('<') => sugg,
 948                     _ => format!("<{}>", sugg),
 949                 };
 950                 let sugg_label = "use `dyn`";
 951                 if self.sess().edition() >= Edition::Edition2021 {
 952                     let mut err = rustc_errors::struct_span_err!(
 953                         self.sess(),
 954                         self_ty.span,
 955                         E0782,
 956                         "{}",
 957                         msg,
 958                     );
 959                     err.span_suggestion(
 960                         self_ty.span,
 961                         sugg_label,
 962                         sugg,
 963                         Applicability::MachineApplicable,
 964                     )
 965                     .emit();
 966                 } else {
 967                     self.tcx.struct_span_lint_hir(
 968                         BARE_TRAIT_OBJECTS,
 969                         hir_id,
 970                         self_ty.span,
 971                         |lint| {
 972                             let mut db = lint.build(msg);
 973                             db.span_suggestion(self_ty.span, sugg_label, sugg, app);
 974                             db.emit()
 975                         },
 976                     );
 977                 }
 978             }
 979         }
 980     }
 981
 982     /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
 983     pub(in super::super) fn get_node_fn_decl(
 984         &self,
 985         node: Node<'tcx>,
 986     ) -> Option<(&'tcx hir::FnDecl<'tcx>, Ident, bool)> {
 987         match node {
 988             Node::Item(&hir::Item { ident, kind: hir::ItemKind::Fn(ref sig, ..), .. }) => {
 989                 // This is less than ideal, it will not suggest a return type span on any
 990                 // method called `main`, regardless of whether it is actually the entry point,
 991                 // but it will still present it as the reason for the expected type.
 992                 Some((&sig.decl, ident, ident.name != sym::main))
 993             }
 994             Node::TraitItem(&hir::TraitItem {
 995                 ident,
 996                 kind: hir::TraitItemKind::Fn(ref sig, ..),
 997                 ..
 998             }) => Some((&sig.decl, ident, true)),
 999             Node::ImplItem(&hir::ImplItem {
1000                 ident,
1001                 kind: hir::ImplItemKind::Fn(ref sig, ..),
1002                 ..
1003             }) => Some((&sig.decl, ident, false)),
1004             _ => None,
1005         }
1006     }
1007
1008     /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
1009     /// suggestion can be made, `None` otherwise.
1010     pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl<'tcx>, bool)> {
1011         // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
1012         // `while` before reaching it, as block tail returns are not available in them.
1013         self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
1014             let parent = self.tcx.hir().get(blk_id);
1015             self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
1016         })
1017     }
1018
1019     pub(in super::super) fn note_internal_mutation_in_method(
1020         &self,
1021         err: &mut DiagnosticBuilder<'_>,
1022         expr: &hir::Expr<'_>,
1023         expected: Ty<'tcx>,
1024         found: Ty<'tcx>,
1025     ) {
1026         if found != self.tcx.types.unit {
1027             return;
1028         }
1029         if let ExprKind::MethodCall(path_segment, _, [rcvr, ..], _) = expr.kind {
1030             if self
1031                 .typeck_results
1032                 .borrow()
1033                 .expr_ty_adjusted_opt(rcvr)
1034                 .map_or(true, |ty| expected.peel_refs() != ty.peel_refs())
1035             {
1036                 return;
1037             }
1038             let mut sp = MultiSpan::from_span(path_segment.ident.span);
1039             sp.push_span_label(
1040                 path_segment.ident.span,
1041                 format!(
1042                     "this call modifies {} in-place",
1043                     match rcvr.kind {
1044                         ExprKind::Path(QPath::Resolved(
1045                             None,
1046                             hir::Path { segments: [segment], .. },
1047                         )) => format!("`{}`", segment.ident),
1048                         _ => "its receiver".to_string(),
1049                     }
1050                 ),
1051             );
1052             sp.push_span_label(
1053                 rcvr.span,
1054                 "you probably want to use this value after calling the method...".to_string(),
1055             );
1056             err.span_note(
1057                 sp,
1058                 &format!("method `{}` modifies its receiver in-place", path_segment.ident),
1059             );
1060             err.note(&format!("...instead of the `()` output of method `{}`", path_segment.ident));
1061         }
1062     }
1063
1064     pub(in super::super) fn note_need_for_fn_pointer(
1065         &self,
1066         err: &mut DiagnosticBuilder<'_>,
1067         expected: Ty<'tcx>,
1068         found: Ty<'tcx>,
1069     ) {
1070         let (sig, did, substs) = match (&expected.kind(), &found.kind()) {
1071             (ty::FnDef(did1, substs1), ty::FnDef(did2, substs2)) => {
1072                 let sig1 = self.tcx.fn_sig(*did1).subst(self.tcx, substs1);
1073                 let sig2 = self.tcx.fn_sig(*did2).subst(self.tcx, substs2);
1074                 if sig1 != sig2 {
1075                     return;
1076                 }
1077                 err.note(
1078                     "different `fn` items always have unique types, even if their signatures are \
1079                      the same",
1080                 );
1081                 (sig1, *did1, substs1)
1082             }
1083             (ty::FnDef(did, substs), ty::FnPtr(sig2)) => {
1084                 let sig1 = self.tcx.fn_sig(*did).subst(self.tcx, substs);
1085                 if sig1 != *sig2 {
1086                     return;
1087                 }
1088                 (sig1, *did, substs)
1089             }
1090             _ => return,
1091         };
1092         err.help(&format!("change the expected type to be function pointer `{}`", sig));
1093         err.help(&format!(
1094             "if the expected type is due to type inference, cast the expected `fn` to a function \
1095              pointer: `{} as {}`",
1096             self.tcx.def_path_str_with_substs(did, substs),
1097             sig
1098         ));
1099     }
1100
1101     pub(in super::super) fn could_remove_semicolon(
1102         &self,
1103         blk: &'tcx hir::Block<'tcx>,
1104         expected_ty: Ty<'tcx>,
1105     ) -> Option<(Span, StatementAsExpression)> {
1106         // Be helpful when the user wrote `{... expr;}` and
1107         // taking the `;` off is enough to fix the error.
1108         let last_stmt = blk.stmts.last()?;
1109         let last_expr = match last_stmt.kind {
1110             hir::StmtKind::Semi(ref e) => e,
1111             _ => return None,
1112         };
1113         let last_expr_ty = self.node_ty(last_expr.hir_id);
1114         let needs_box = match (last_expr_ty.kind(), expected_ty.kind()) {
1115             (ty::Opaque(last_def_id, _), ty::Opaque(exp_def_id, _))
1116                 if last_def_id == exp_def_id =>
1117             {
1118                 StatementAsExpression::CorrectType
1119             }
1120             (ty::Opaque(last_def_id, last_bounds), ty::Opaque(exp_def_id, exp_bounds)) => {
1121                 debug!(
1122                     "both opaque, likely future {:?} {:?} {:?} {:?}",
1123                     last_def_id, last_bounds, exp_def_id, exp_bounds
1124                 );
1125
1126                 let (last_local_id, exp_local_id) =
1127                     match (last_def_id.as_local(), exp_def_id.as_local()) {
1128                         (Some(last_hir_id), Some(exp_hir_id)) => (last_hir_id, exp_hir_id),
1129                         (_, _) => return None,
1130                     };
1131
1132                 let last_hir_id = self.tcx.hir().local_def_id_to_hir_id(last_local_id);
1133                 let exp_hir_id = self.tcx.hir().local_def_id_to_hir_id(exp_local_id);
1134
1135                 match (
1136                     &self.tcx.hir().expect_item(last_hir_id).kind,
1137                     &self.tcx.hir().expect_item(exp_hir_id).kind,
1138                 ) {
1139                     (
1140                         hir::ItemKind::OpaqueTy(hir::OpaqueTy { bounds: last_bounds, .. }),
1141                         hir::ItemKind::OpaqueTy(hir::OpaqueTy { bounds: exp_bounds, .. }),
1142                     ) if iter::zip(*last_bounds, *exp_bounds).all(|(left, right)| {
1143                         match (left, right) {
1144                             (
1145                                 hir::GenericBound::Trait(tl, ml),
1146                                 hir::GenericBound::Trait(tr, mr),
1147                             ) if tl.trait_ref.trait_def_id() == tr.trait_ref.trait_def_id()
1148                                 && ml == mr =>
1149                             {
1150                                 true
1151                             }
1152                             (
1153                                 hir::GenericBound::LangItemTrait(langl, _, _, argsl),
1154                                 hir::GenericBound::LangItemTrait(langr, _, _, argsr),
1155                             ) if langl == langr => {
1156                                 // FIXME: consider the bounds!
1157                                 debug!("{:?} {:?}", argsl, argsr);
1158                                 true
1159                             }
1160                             _ => false,
1161                         }
1162                     }) =>
1163                     {
1164                         StatementAsExpression::NeedsBoxing
1165                     }
1166                     _ => StatementAsExpression::CorrectType,
1167                 }
1168             }
1169             _ => StatementAsExpression::CorrectType,
1170         };
1171         if (matches!(last_expr_ty.kind(), ty::Error(_))
1172             || self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err())
1173             && matches!(needs_box, StatementAsExpression::CorrectType)
1174         {
1175             return None;
1176         }
1177         let span = if last_stmt.span.from_expansion() {
1178             let mac_call = original_sp(last_stmt.span, blk.span);
1179             self.tcx.sess.source_map().mac_call_stmt_semi_span(mac_call)?
1180         } else {
1181             last_stmt.span.with_lo(last_stmt.span.hi() - BytePos(1))
1182         };
1183         Some((span, needs_box))
1184     }
1185
1186     // Instantiates the given path, which must refer to an item with the given
1187     // number of type parameters and type.
1188     #[instrument(skip(self, span), level = "debug")]
1189     pub fn instantiate_value_path(
1190         &self,
1191         segments: &[hir::PathSegment<'_>],
1192         self_ty: Option<Ty<'tcx>>,
1193         res: Res,
1194         span: Span,
1195         hir_id: hir::HirId,
1196     ) -> (Ty<'tcx>, Res) {
1197         let tcx = self.tcx;
1198
1199         let path_segs = match res {
1200             Res::Local(_) | Res::SelfCtor(_) => vec![],
1201             Res::Def(kind, def_id) => <dyn AstConv<'_>>::def_ids_for_value_path_segments(
1202                 self, segments, self_ty, kind, def_id,
1203             ),
1204             _ => bug!("instantiate_value_path on {:?}", res),
1205         };
1206
1207         let mut user_self_ty = None;
1208         let mut is_alias_variant_ctor = false;
1209         match res {
1210             Res::Def(DefKind::Ctor(CtorOf::Variant, _), _)
1211                 if let Some(self_ty) = self_ty =>
1212             {
1213                 let adt_def = self_ty.ty_adt_def().unwrap();
1214                 user_self_ty = Some(UserSelfTy { impl_def_id: adt_def.did, self_ty });
1215                 is_alias_variant_ctor = true;
1216             }
1217             Res::Def(DefKind::AssocFn | DefKind::AssocConst, def_id) => {
1218                 let container = tcx.associated_item(def_id).container;
1219                 debug!(?def_id, ?container);
1220                 match container {
1221                     ty::TraitContainer(trait_did) => {
1222                         callee::check_legal_trait_for_method_call(tcx, span, None, span, trait_did)
1223                     }
1224                     ty::ImplContainer(impl_def_id) => {
1225                         if segments.len() == 1 {
1226                             // `<T>::assoc` will end up here, and so
1227                             // can `T::assoc`. It this came from an
1228                             // inherent impl, we need to record the
1229                             // `T` for posterity (see `UserSelfTy` for
1230                             // details).
1231                             let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
1232                             user_self_ty = Some(UserSelfTy { impl_def_id, self_ty });
1233                         }
1234                     }
1235                 }
1236             }
1237             _ => {}
1238         }
1239
1240         // Now that we have categorized what space the parameters for each
1241         // segment belong to, let's sort out the parameters that the user
1242         // provided (if any) into their appropriate spaces. We'll also report
1243         // errors if type parameters are provided in an inappropriate place.
1244
1245         let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
1246         let generics_has_err = <dyn AstConv<'_>>::prohibit_generics(
1247             self,
1248             segments.iter().enumerate().filter_map(|(index, seg)| {
1249                 if !generic_segs.contains(&index) || is_alias_variant_ctor {
1250                     Some(seg)
1251                 } else {
1252                     None
1253                 }
1254             }),
1255         );
1256
1257         if let Res::Local(hid) = res {
1258             let ty = self.local_ty(span, hid).decl_ty;
1259             let ty = self.normalize_associated_types_in(span, ty);
1260             self.write_ty(hir_id, ty);
1261             return (ty, res);
1262         }
1263
1264         if generics_has_err {
1265             // Don't try to infer type parameters when prohibited generic arguments were given.
1266             user_self_ty = None;
1267         }
1268
1269         // Now we have to compare the types that the user *actually*
1270         // provided against the types that were *expected*. If the user
1271         // did not provide any types, then we want to substitute inference
1272         // variables. If the user provided some types, we may still need
1273         // to add defaults. If the user provided *too many* types, that's
1274         // a problem.
1275
1276         let mut infer_args_for_err = FxHashSet::default();
1277
1278         let mut explicit_late_bound = ExplicitLateBound::No;
1279         for &PathSeg(def_id, index) in &path_segs {
1280             let seg = &segments[index];
1281             let generics = tcx.generics_of(def_id);
1282
1283             // Argument-position `impl Trait` is treated as a normal generic
1284             // parameter internally, but we don't allow users to specify the
1285             // parameter's value explicitly, so we have to do some error-
1286             // checking here.
1287             let arg_count = <dyn AstConv<'_>>::check_generic_arg_count_for_call(
1288                 tcx,
1289                 span,
1290                 def_id,
1291                 &generics,
1292                 seg,
1293                 IsMethodCall::No,
1294             );
1295
1296             if let ExplicitLateBound::Yes = arg_count.explicit_late_bound {
1297                 explicit_late_bound = ExplicitLateBound::Yes;
1298             }
1299
1300             if let Err(GenericArgCountMismatch { reported: Some(_), .. }) = arg_count.correct {
1301                 infer_args_for_err.insert(index);
1302                 self.set_tainted_by_errors(); // See issue #53251.
1303             }
1304         }
1305
1306         let has_self = path_segs
1307             .last()
1308             .map(|PathSeg(def_id, _)| tcx.generics_of(*def_id).has_self)
1309             .unwrap_or(false);
1310
1311         let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
1312             let ty = self.normalize_ty(span, tcx.at(span).type_of(impl_def_id));
1313             match *ty.kind() {
1314                 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
1315                     let variant = adt_def.non_enum_variant();
1316                     let ctor_def_id = variant.ctor_def_id.unwrap();
1317                     (
1318                         Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
1319                         Some(substs),
1320                     )
1321                 }
1322                 _ => {
1323                     let mut err = tcx.sess.struct_span_err(
1324                         span,
1325                         "the `Self` constructor can only be used with tuple or unit structs",
1326                     );
1327                     if let Some(adt_def) = ty.ty_adt_def() {
1328                         match adt_def.adt_kind() {
1329                             AdtKind::Enum => {
1330                                 err.help("did you mean to use one of the enum's variants?");
1331                             }
1332                             AdtKind::Struct | AdtKind::Union => {
1333                                 err.span_suggestion(
1334                                     span,
1335                                     "use curly brackets",
1336                                     String::from("Self { /* fields */ }"),
1337                                     Applicability::HasPlaceholders,
1338                                 );
1339                             }
1340                         }
1341                     }
1342                     err.emit();
1343
1344                     return (tcx.ty_error(), res);
1345                 }
1346             }
1347         } else {
1348             (res, None)
1349         };
1350         let def_id = res.def_id();
1351
1352         // The things we are substituting into the type should not contain
1353         // escaping late-bound regions, and nor should the base type scheme.
1354         let ty = tcx.type_of(def_id);
1355
1356         let arg_count = GenericArgCountResult {
1357             explicit_late_bound,
1358             correct: if infer_args_for_err.is_empty() {
1359                 Ok(())
1360             } else {
1361                 Err(GenericArgCountMismatch::default())
1362             },
1363         };
1364
1365         struct CreateCtorSubstsContext<'a, 'tcx> {
1366             fcx: &'a FnCtxt<'a, 'tcx>,
1367             span: Span,
1368             path_segs: &'a [PathSeg],
1369             infer_args_for_err: &'a FxHashSet<usize>,
1370             segments: &'a [hir::PathSegment<'a>],
1371         }
1372         impl<'tcx, 'a> CreateSubstsForGenericArgsCtxt<'a, 'tcx> for CreateCtorSubstsContext<'a, 'tcx> {
1373             fn args_for_def_id(
1374                 &mut self,
1375                 def_id: DefId,
1376             ) -> (Option<&'a hir::GenericArgs<'a>>, bool) {
1377                 if let Some(&PathSeg(_, index)) =
1378                     self.path_segs.iter().find(|&PathSeg(did, _)| *did == def_id)
1379                 {
1380                     // If we've encountered an `impl Trait`-related error, we're just
1381                     // going to infer the arguments for better error messages.
1382                     if !self.infer_args_for_err.contains(&index) {
1383                         // Check whether the user has provided generic arguments.
1384                         if let Some(ref data) = self.segments[index].args {
1385                             return (Some(data), self.segments[index].infer_args);
1386                         }
1387                     }
1388                     return (None, self.segments[index].infer_args);
1389                 }
1390
1391                 (None, true)
1392             }
1393
1394             fn provided_kind(
1395                 &mut self,
1396                 param: &ty::GenericParamDef,
1397                 arg: &GenericArg<'_>,
1398             ) -> subst::GenericArg<'tcx> {
1399                 match (&param.kind, arg) {
1400                     (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
1401                         <dyn AstConv<'_>>::ast_region_to_region(self.fcx, lt, Some(param)).into()
1402                     }
1403                     (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
1404                         self.fcx.to_ty(ty).into()
1405                     }
1406                     (GenericParamDefKind::Const { .. }, GenericArg::Const(ct)) => {
1407                         self.fcx.const_arg_to_const(&ct.value, param.def_id).into()
1408                     }
1409                     (GenericParamDefKind::Type { .. }, GenericArg::Infer(inf)) => {
1410                         self.fcx.ty_infer(Some(param), inf.span).into()
1411                     }
1412                     (GenericParamDefKind::Const { .. }, GenericArg::Infer(inf)) => {
1413                         let tcx = self.fcx.tcx();
1414                         self.fcx.ct_infer(tcx.type_of(param.def_id), Some(param), inf.span).into()
1415                     }
1416                     _ => unreachable!(),
1417                 }
1418             }
1419
1420             fn inferred_kind(
1421                 &mut self,
1422                 substs: Option<&[subst::GenericArg<'tcx>]>,
1423                 param: &ty::GenericParamDef,
1424                 infer_args: bool,
1425             ) -> subst::GenericArg<'tcx> {
1426                 let tcx = self.fcx.tcx();
1427                 match param.kind {
1428                     GenericParamDefKind::Lifetime => {
1429                         self.fcx.re_infer(Some(param), self.span).unwrap().into()
1430                     }
1431                     GenericParamDefKind::Type { has_default, .. } => {
1432                         if !infer_args && has_default {
1433                             // If we have a default, then we it doesn't matter that we're not
1434                             // inferring the type arguments: we provide the default where any
1435                             // is missing.
1436                             let default = tcx.type_of(param.def_id);
1437                             self.fcx
1438                                 .normalize_ty(
1439                                     self.span,
1440                                     default.subst_spanned(tcx, substs.unwrap(), Some(self.span)),
1441                                 )
1442                                 .into()
1443                         } else {
1444                             // If no type arguments were provided, we have to infer them.
1445                             // This case also occurs as a result of some malformed input, e.g.
1446                             // a lifetime argument being given instead of a type parameter.
1447                             // Using inference instead of `Error` gives better error messages.
1448                             self.fcx.var_for_def(self.span, param)
1449                         }
1450                     }
1451                     GenericParamDefKind::Const { has_default, .. } => {
1452                         if !infer_args && has_default {
1453                             tcx.const_param_default(param.def_id)
1454                                 .subst_spanned(tcx, substs.unwrap(), Some(self.span))
1455                                 .into()
1456                         } else {
1457                             self.fcx.var_for_def(self.span, param)
1458                         }
1459                     }
1460                 }
1461             }
1462         }
1463
1464         let substs = self_ctor_substs.unwrap_or_else(|| {
1465             <dyn AstConv<'_>>::create_substs_for_generic_args(
1466                 tcx,
1467                 def_id,
1468                 &[][..],
1469                 has_self,
1470                 self_ty,
1471                 &arg_count,
1472                 &mut CreateCtorSubstsContext {
1473                     fcx: self,
1474                     span,
1475                     path_segs: &path_segs,
1476                     infer_args_for_err: &infer_args_for_err,
1477                     segments,
1478                 },
1479             )
1480         });
1481         assert!(!substs.has_escaping_bound_vars());
1482         assert!(!ty.has_escaping_bound_vars());
1483
1484         // First, store the "user substs" for later.
1485         self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
1486
1487         self.add_required_obligations(span, def_id, &substs);
1488
1489         // Substitute the values for the type parameters into the type of
1490         // the referenced item.
1491         let ty_substituted = self.instantiate_type_scheme(span, &substs, ty);
1492
1493         if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
1494             // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
1495             // is inherent, there is no `Self` parameter; instead, the impl needs
1496             // type parameters, which we can infer by unifying the provided `Self`
1497             // with the substituted impl type.
1498             // This also occurs for an enum variant on a type alias.
1499             let ty = tcx.type_of(impl_def_id);
1500
1501             let impl_ty = self.instantiate_type_scheme(span, &substs, ty);
1502             match self.at(&self.misc(span), self.param_env).eq(impl_ty, self_ty) {
1503                 Ok(ok) => self.register_infer_ok_obligations(ok),
1504                 Err(_) => {
1505                     self.tcx.sess.delay_span_bug(
1506                         span,
1507                         &format!(
1508                         "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
1509                         self_ty,
1510                         impl_ty,
1511                     ),
1512                     );
1513                 }
1514             }
1515         }
1516
1517         debug!("instantiate_value_path: type of {:?} is {:?}", hir_id, ty_substituted);
1518         self.write_substs(hir_id, substs);
1519
1520         (ty_substituted, res)
1521     }
1522
1523     /// Add all the obligations that are required, substituting and normalized appropriately.
1524     #[tracing::instrument(level = "debug", skip(self, span, def_id, substs))]
1525     fn add_required_obligations(&self, span: Span, def_id: DefId, substs: &SubstsRef<'tcx>) {
1526         let (bounds, spans) = self.instantiate_bounds(span, def_id, &substs);
1527
1528         for (i, mut obligation) in traits::predicates_for_generics(
1529             traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
1530             self.param_env,
1531             bounds,
1532         )
1533         .enumerate()
1534         {
1535             // This makes the error point at the bound, but we want to point at the argument
1536             if let Some(span) = spans.get(i) {
1537                 obligation.cause.make_mut().code = traits::BindingObligation(def_id, *span);
1538             }
1539             self.register_predicate(obligation);
1540         }
1541     }
1542
1543     /// Resolves `typ` by a single level if `typ` is a type variable.
1544     /// If no resolution is possible, then an error is reported.
1545     /// Numeric inference variables may be left unresolved.
1546     pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1547         let ty = self.resolve_vars_with_obligations(ty);
1548         if !ty.is_ty_var() {
1549             ty
1550         } else {
1551             if !self.is_tainted_by_errors() {
1552                 self.emit_inference_failure_err((**self).body_id, sp, ty.into(), vec![], E0282)
1553                     .note("type must be known at this point")
1554                     .emit();
1555             }
1556             let err = self.tcx.ty_error();
1557             self.demand_suptype(sp, err, ty);
1558             err
1559         }
1560     }
1561
1562     pub(in super::super) fn with_breakable_ctxt<F: FnOnce() -> R, R>(
1563         &self,
1564         id: hir::HirId,
1565         ctxt: BreakableCtxt<'tcx>,
1566         f: F,
1567     ) -> (BreakableCtxt<'tcx>, R) {
1568         let index;
1569         {
1570             let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
1571             index = enclosing_breakables.stack.len();
1572             enclosing_breakables.by_id.insert(id, index);
1573             enclosing_breakables.stack.push(ctxt);
1574         }
1575         let result = f();
1576         let ctxt = {
1577             let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
1578             debug_assert!(enclosing_breakables.stack.len() == index + 1);
1579             enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
1580             enclosing_breakables.stack.pop().expect("missing breakable context")
1581         };
1582         (ctxt, result)
1583     }
1584
1585     /// Instantiate a QueryResponse in a probe context, without a
1586     /// good ObligationCause.
1587     pub(in super::super) fn probe_instantiate_query_response(
1588         &self,
1589         span: Span,
1590         original_values: &OriginalQueryValues<'tcx>,
1591         query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
1592     ) -> InferResult<'tcx, Ty<'tcx>> {
1593         self.instantiate_query_response_and_region_obligations(
1594             &traits::ObligationCause::misc(span, self.body_id),
1595             self.param_env,
1596             original_values,
1597             query_result,
1598         )
1599     }
1600
1601     /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
1602     pub(in super::super) fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
1603         let mut contained_in_place = false;
1604
1605         while let hir::Node::Expr(parent_expr) =
1606             self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
1607         {
1608             match &parent_expr.kind {
1609                 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
1610                     if lhs.hir_id == expr_id {
1611                         contained_in_place = true;
1612                         break;
1613                     }
1614                 }
1615                 _ => (),
1616             }
1617             expr_id = parent_expr.hir_id;
1618         }
1619
1620         contained_in_place
1621     }
1622 }