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