compiler/rustc_typeck/src/check/method/confirm.rs

   1 use super::{probe, MethodCallee};
   2
   3 use crate::astconv::{AstConv, CreateSubstsForGenericArgsCtxt, IsMethodCall};
   4 use crate::check::{callee, FnCtxt};
   5 use rustc_hir as hir;
   6 use rustc_hir::def_id::DefId;
   7 use rustc_hir::GenericArg;
   8 use rustc_infer::infer::{self, InferOk};
   9 use rustc_middle::traits::{ObligationCauseCode, UnifyReceiverContext};
  10 use rustc_middle::ty::adjustment::{Adjust, Adjustment, PointerCast};
  11 use rustc_middle::ty::adjustment::{AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
  12 use rustc_middle::ty::fold::TypeFoldable;
  13 use rustc_middle::ty::subst::{self, SubstsRef};
  14 use rustc_middle::ty::{self, GenericParamDefKind, Ty};
  15 use rustc_span::Span;
  16 use rustc_trait_selection::traits;
  17
  18 use std::iter;
  19 use std::ops::Deref;
  20
  21 struct ConfirmContext<'a, 'tcx> {
  22     fcx: &'a FnCtxt<'a, 'tcx>,
  23     span: Span,
  24     self_expr: &'tcx hir::Expr<'tcx>,
  25     call_expr: &'tcx hir::Expr<'tcx>,
  26 }
  27
  28 impl<'a, 'tcx> Deref for ConfirmContext<'a, 'tcx> {
  29     type Target = FnCtxt<'a, 'tcx>;
  30     fn deref(&self) -> &Self::Target {
  31         self.fcx
  32     }
  33 }
  34
  35 #[derive(Debug)]
  36 pub struct ConfirmResult<'tcx> {
  37     pub callee: MethodCallee<'tcx>,
  38     pub illegal_sized_bound: Option<Span>,
  39 }
  40
  41 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  42     pub fn confirm_method(
  43         &self,
  44         span: Span,
  45         self_expr: &'tcx hir::Expr<'tcx>,
  46         call_expr: &'tcx hir::Expr<'tcx>,
  47         unadjusted_self_ty: Ty<'tcx>,
  48         pick: probe::Pick<'tcx>,
  49         segment: &hir::PathSegment<'_>,
  50     ) -> ConfirmResult<'tcx> {
  51         debug!(
  52             "confirm(unadjusted_self_ty={:?}, pick={:?}, generic_args={:?})",
  53             unadjusted_self_ty, pick, segment.args,
  54         );
  55
  56         let mut confirm_cx = ConfirmContext::new(self, span, self_expr, call_expr);
  57         confirm_cx.confirm(unadjusted_self_ty, pick, segment)
  58     }
  59 }
  60
  61 impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
  62     fn new(
  63         fcx: &'a FnCtxt<'a, 'tcx>,
  64         span: Span,
  65         self_expr: &'tcx hir::Expr<'tcx>,
  66         call_expr: &'tcx hir::Expr<'tcx>,
  67     ) -> ConfirmContext<'a, 'tcx> {
  68         ConfirmContext { fcx, span, self_expr, call_expr }
  69     }
  70
  71     fn confirm(
  72         &mut self,
  73         unadjusted_self_ty: Ty<'tcx>,
  74         pick: probe::Pick<'tcx>,
  75         segment: &hir::PathSegment<'_>,
  76     ) -> ConfirmResult<'tcx> {
  77         // Adjust the self expression the user provided and obtain the adjusted type.
  78         let self_ty = self.adjust_self_ty(unadjusted_self_ty, &pick);
  79
  80         // Create substitutions for the method's type parameters.
  81         let rcvr_substs = self.fresh_receiver_substs(self_ty, &pick);
  82         let all_substs = self.instantiate_method_substs(&pick, segment, rcvr_substs);
  83
  84         debug!("rcvr_substs={rcvr_substs:?}, all_substs={all_substs:?}");
  85
  86         // Create the final signature for the method, replacing late-bound regions.
  87         let (method_sig, method_predicates) = self.instantiate_method_sig(&pick, all_substs);
  88
  89         // If there is a `Self: Sized` bound and `Self` is a trait object, it is possible that
  90         // something which derefs to `Self` actually implements the trait and the caller
  91         // wanted to make a static dispatch on it but forgot to import the trait.
  92         // See test `src/test/ui/issue-35976.rs`.
  93         //
  94         // In that case, we'll error anyway, but we'll also re-run the search with all traits
  95         // in scope, and if we find another method which can be used, we'll output an
  96         // appropriate hint suggesting to import the trait.
  97         let filler_substs = rcvr_substs
  98             .extend_to(self.tcx, pick.item.def_id, |def, _| self.tcx.mk_param_from_def(def));
  99         let illegal_sized_bound = self.predicates_require_illegal_sized_bound(
 100             &self.tcx.predicates_of(pick.item.def_id).instantiate(self.tcx, filler_substs),
 101         );
 102
 103         // Unify the (adjusted) self type with what the method expects.
 104         //
 105         // SUBTLE: if we want good error messages, because of "guessing" while matching
 106         // traits, no trait system method can be called before this point because they
 107         // could alter our Self-type, except for normalizing the receiver from the
 108         // signature (which is also done during probing).
 109         let method_sig_rcvr = self.normalize_associated_types_in(self.span, method_sig.inputs()[0]);
 110         debug!(
 111             "confirm: self_ty={:?} method_sig_rcvr={:?} method_sig={:?} method_predicates={:?}",
 112             self_ty, method_sig_rcvr, method_sig, method_predicates
 113         );
 114         self.unify_receivers(self_ty, method_sig_rcvr, &pick, all_substs);
 115
 116         let (method_sig, method_predicates) =
 117             self.normalize_associated_types_in(self.span, (method_sig, method_predicates));
 118         let method_sig = ty::Binder::dummy(method_sig);
 119
 120         // Make sure nobody calls `drop()` explicitly.
 121         self.enforce_illegal_method_limitations(&pick);
 122
 123         // Add any trait/regions obligations specified on the method's type parameters.
 124         // We won't add these if we encountered an illegal sized bound, so that we can use
 125         // a custom error in that case.
 126         if illegal_sized_bound.is_none() {
 127             self.add_obligations(
 128                 self.tcx.mk_fn_ptr(method_sig),
 129                 all_substs,
 130                 method_predicates,
 131                 pick.item.def_id,
 132             );
 133         }
 134
 135         // Create the final `MethodCallee`.
 136         let callee = MethodCallee {
 137             def_id: pick.item.def_id,
 138             substs: all_substs,
 139             sig: method_sig.skip_binder(),
 140         };
 141         ConfirmResult { callee, illegal_sized_bound }
 142     }
 143
 144     ///////////////////////////////////////////////////////////////////////////
 145     // ADJUSTMENTS
 146
 147     fn adjust_self_ty(
 148         &mut self,
 149         unadjusted_self_ty: Ty<'tcx>,
 150         pick: &probe::Pick<'tcx>,
 151     ) -> Ty<'tcx> {
 152         // Commit the autoderefs by calling `autoderef` again, but this
 153         // time writing the results into the various typeck results.
 154         let mut autoderef =
 155             self.autoderef_overloaded_span(self.span, unadjusted_self_ty, self.call_expr.span);
 156         let Some((ty, n)) = autoderef.nth(pick.autoderefs) else {
 157             return self.tcx.ty_error_with_message(
 158                 rustc_span::DUMMY_SP,
 159                 &format!("failed autoderef {}", pick.autoderefs),
 160             );
 161         };
 162         assert_eq!(n, pick.autoderefs);
 163
 164         let mut adjustments = self.adjust_steps(&autoderef);
 165         let mut target = self.structurally_resolved_type(autoderef.span(), ty);
 166
 167         match pick.autoref_or_ptr_adjustment {
 168             Some(probe::AutorefOrPtrAdjustment::Autoref { mutbl, unsize }) => {
 169                 let region = self.next_region_var(infer::Autoref(self.span));
 170                 // Type we're wrapping in a reference, used later for unsizing
 171                 let base_ty = target;
 172
 173                 target = self.tcx.mk_ref(region, ty::TypeAndMut { mutbl, ty: target });
 174                 let mutbl = match mutbl {
 175                     hir::Mutability::Not => AutoBorrowMutability::Not,
 176                     hir::Mutability::Mut => AutoBorrowMutability::Mut {
 177                         // Method call receivers are the primary use case
 178                         // for two-phase borrows.
 179                         allow_two_phase_borrow: AllowTwoPhase::Yes,
 180                     },
 181                 };
 182                 adjustments.push(Adjustment {
 183                     kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
 184                     target,
 185                 });
 186
 187                 if unsize {
 188                     let unsized_ty = if let ty::Array(elem_ty, _) = base_ty.kind() {
 189                         self.tcx.mk_slice(*elem_ty)
 190                     } else {
 191                         bug!(
 192                             "AutorefOrPtrAdjustment's unsize flag should only be set for array ty, found {}",
 193                             base_ty
 194                         )
 195                     };
 196                     target = self
 197                         .tcx
 198                         .mk_ref(region, ty::TypeAndMut { mutbl: mutbl.into(), ty: unsized_ty });
 199                     adjustments
 200                         .push(Adjustment { kind: Adjust::Pointer(PointerCast::Unsize), target });
 201                 }
 202             }
 203             Some(probe::AutorefOrPtrAdjustment::ToConstPtr) => {
 204                 target = match target.kind() {
 205                     &ty::RawPtr(ty::TypeAndMut { ty, mutbl }) => {
 206                         assert_eq!(mutbl, hir::Mutability::Mut);
 207                         self.tcx.mk_ptr(ty::TypeAndMut { mutbl: hir::Mutability::Not, ty })
 208                     }
 209                     other => panic!("Cannot adjust receiver type {:?} to const ptr", other),
 210                 };
 211
 212                 adjustments.push(Adjustment {
 213                     kind: Adjust::Pointer(PointerCast::MutToConstPointer),
 214                     target,
 215                 });
 216             }
 217             None => {}
 218         }
 219
 220         self.register_predicates(autoderef.into_obligations());
 221
 222         // Write out the final adjustments.
 223         self.apply_adjustments(self.self_expr, adjustments);
 224
 225         target
 226     }
 227
 228     /// Returns a set of substitutions for the method *receiver* where all type and region
 229     /// parameters are instantiated with fresh variables. This substitution does not include any
 230     /// parameters declared on the method itself.
 231     ///
 232     /// Note that this substitution may include late-bound regions from the impl level. If so,
 233     /// these are instantiated later in the `instantiate_method_sig` routine.
 234     fn fresh_receiver_substs(
 235         &mut self,
 236         self_ty: Ty<'tcx>,
 237         pick: &probe::Pick<'tcx>,
 238     ) -> SubstsRef<'tcx> {
 239         match pick.kind {
 240             probe::InherentImplPick => {
 241                 let impl_def_id = pick.item.container_id(self.tcx);
 242                 assert!(
 243                     self.tcx.impl_trait_ref(impl_def_id).is_none(),
 244                     "impl {:?} is not an inherent impl",
 245                     impl_def_id
 246                 );
 247                 self.fresh_substs_for_item(self.span, impl_def_id)
 248             }
 249
 250             probe::ObjectPick => {
 251                 let trait_def_id = pick.item.container_id(self.tcx);
 252                 self.extract_existential_trait_ref(self_ty, |this, object_ty, principal| {
 253                     // The object data has no entry for the Self
 254                     // Type. For the purposes of this method call, we
 255                     // substitute the object type itself. This
 256                     // wouldn't be a sound substitution in all cases,
 257                     // since each instance of the object type is a
 258                     // different existential and hence could match
 259                     // distinct types (e.g., if `Self` appeared as an
 260                     // argument type), but those cases have already
 261                     // been ruled out when we deemed the trait to be
 262                     // "object safe".
 263                     let original_poly_trait_ref = principal.with_self_ty(this.tcx, object_ty);
 264                     let upcast_poly_trait_ref = this.upcast(original_poly_trait_ref, trait_def_id);
 265                     let upcast_trait_ref =
 266                         this.replace_bound_vars_with_fresh_vars(upcast_poly_trait_ref);
 267                     debug!(
 268                         "original_poly_trait_ref={:?} upcast_trait_ref={:?} target_trait={:?}",
 269                         original_poly_trait_ref, upcast_trait_ref, trait_def_id
 270                     );
 271                     upcast_trait_ref.substs
 272                 })
 273             }
 274
 275             probe::TraitPick => {
 276                 let trait_def_id = pick.item.container_id(self.tcx);
 277
 278                 // Make a trait reference `$0 : Trait<$1...$n>`
 279                 // consisting entirely of type variables. Later on in
 280                 // the process we will unify the transformed-self-type
 281                 // of the method with the actual type in order to
 282                 // unify some of these variables.
 283                 self.fresh_substs_for_item(self.span, trait_def_id)
 284             }
 285
 286             probe::WhereClausePick(poly_trait_ref) => {
 287                 // Where clauses can have bound regions in them. We need to instantiate
 288                 // those to convert from a poly-trait-ref to a trait-ref.
 289                 self.replace_bound_vars_with_fresh_vars(poly_trait_ref).substs
 290             }
 291         }
 292     }
 293
 294     fn extract_existential_trait_ref<R, F>(&mut self, self_ty: Ty<'tcx>, mut closure: F) -> R
 295     where
 296         F: FnMut(&mut ConfirmContext<'a, 'tcx>, Ty<'tcx>, ty::PolyExistentialTraitRef<'tcx>) -> R,
 297     {
 298         // If we specified that this is an object method, then the
 299         // self-type ought to be something that can be dereferenced to
 300         // yield an object-type (e.g., `&Object` or `Box<Object>`
 301         // etc).
 302
 303         // FIXME: this feels, like, super dubious
 304         self.fcx
 305             .autoderef(self.span, self_ty)
 306             .include_raw_pointers()
 307             .find_map(|(ty, _)| match ty.kind() {
 308                 ty::Dynamic(data, ..) => Some(closure(
 309                     self,
 310                     ty,
 311                     data.principal().unwrap_or_else(|| {
 312                         span_bug!(self.span, "calling trait method on empty object?")
 313                     }),
 314                 )),
 315                 _ => None,
 316             })
 317             .unwrap_or_else(|| {
 318                 span_bug!(
 319                     self.span,
 320                     "self-type `{}` for ObjectPick never dereferenced to an object",
 321                     self_ty
 322                 )
 323             })
 324     }
 325
 326     fn instantiate_method_substs(
 327         &mut self,
 328         pick: &probe::Pick<'tcx>,
 329         seg: &hir::PathSegment<'_>,
 330         parent_substs: SubstsRef<'tcx>,
 331     ) -> SubstsRef<'tcx> {
 332         // Determine the values for the generic parameters of the method.
 333         // If they were not explicitly supplied, just construct fresh
 334         // variables.
 335         let generics = self.tcx.generics_of(pick.item.def_id);
 336
 337         let arg_count_correct = <dyn AstConv<'_>>::check_generic_arg_count_for_call(
 338             self.tcx,
 339             self.span,
 340             pick.item.def_id,
 341             generics,
 342             seg,
 343             IsMethodCall::Yes,
 344         );
 345
 346         // Create subst for early-bound lifetime parameters, combining
 347         // parameters from the type and those from the method.
 348         assert_eq!(generics.parent_count, parent_substs.len());
 349
 350         struct MethodSubstsCtxt<'a, 'tcx> {
 351             cfcx: &'a ConfirmContext<'a, 'tcx>,
 352             pick: &'a probe::Pick<'tcx>,
 353             seg: &'a hir::PathSegment<'a>,
 354         }
 355         impl<'a, 'tcx> CreateSubstsForGenericArgsCtxt<'a, 'tcx> for MethodSubstsCtxt<'a, 'tcx> {
 356             fn args_for_def_id(
 357                 &mut self,
 358                 def_id: DefId,
 359             ) -> (Option<&'a hir::GenericArgs<'a>>, bool) {
 360                 if def_id == self.pick.item.def_id {
 361                     if let Some(data) = self.seg.args {
 362                         return (Some(data), false);
 363                     }
 364                 }
 365                 (None, false)
 366             }
 367
 368             fn provided_kind(
 369                 &mut self,
 370                 param: &ty::GenericParamDef,
 371                 arg: &GenericArg<'_>,
 372             ) -> subst::GenericArg<'tcx> {
 373                 match (&param.kind, arg) {
 374                     (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
 375                         <dyn AstConv<'_>>::ast_region_to_region(self.cfcx.fcx, lt, Some(param))
 376                             .into()
 377                     }
 378                     (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
 379                         self.cfcx.to_ty(ty).into()
 380                     }
 381                     (GenericParamDefKind::Const { .. }, GenericArg::Const(ct)) => {
 382                         self.cfcx.const_arg_to_const(&ct.value, param.def_id).into()
 383                     }
 384                     (GenericParamDefKind::Type { .. }, GenericArg::Infer(inf)) => {
 385                         self.cfcx.ty_infer(Some(param), inf.span).into()
 386                     }
 387                     (GenericParamDefKind::Const { .. }, GenericArg::Infer(inf)) => {
 388                         let tcx = self.cfcx.tcx();
 389                         self.cfcx.ct_infer(tcx.type_of(param.def_id), Some(param), inf.span).into()
 390                     }
 391                     _ => unreachable!(),
 392                 }
 393             }
 394
 395             fn inferred_kind(
 396                 &mut self,
 397                 _substs: Option<&[subst::GenericArg<'tcx>]>,
 398                 param: &ty::GenericParamDef,
 399                 _infer_args: bool,
 400             ) -> subst::GenericArg<'tcx> {
 401                 self.cfcx.var_for_def(self.cfcx.span, param)
 402             }
 403         }
 404         <dyn AstConv<'_>>::create_substs_for_generic_args(
 405             self.tcx,
 406             pick.item.def_id,
 407             parent_substs,
 408             false,
 409             None,
 410             &arg_count_correct,
 411             &mut MethodSubstsCtxt { cfcx: self, pick, seg },
 412         )
 413     }
 414
 415     fn unify_receivers(
 416         &mut self,
 417         self_ty: Ty<'tcx>,
 418         method_self_ty: Ty<'tcx>,
 419         pick: &probe::Pick<'tcx>,
 420         substs: SubstsRef<'tcx>,
 421     ) {
 422         debug!(
 423             "unify_receivers: self_ty={:?} method_self_ty={:?} span={:?} pick={:?}",
 424             self_ty, method_self_ty, self.span, pick
 425         );
 426         let cause = self.cause(
 427             self.span,
 428             ObligationCauseCode::UnifyReceiver(Box::new(UnifyReceiverContext {
 429                 assoc_item: pick.item,
 430                 param_env: self.param_env,
 431                 substs,
 432             })),
 433         );
 434         match self.at(&cause, self.param_env).sup(method_self_ty, self_ty) {
 435             Ok(InferOk { obligations, value: () }) => {
 436                 self.register_predicates(obligations);
 437             }
 438             Err(_) => {
 439                 span_bug!(
 440                     self.span,
 441                     "{} was a subtype of {} but now is not?",
 442                     self_ty,
 443                     method_self_ty
 444                 );
 445             }
 446         }
 447     }
 448
 449     // NOTE: this returns the *unnormalized* predicates and method sig. Because of
 450     // inference guessing, the predicates and method signature can't be normalized
 451     // until we unify the `Self` type.
 452     fn instantiate_method_sig(
 453         &mut self,
 454         pick: &probe::Pick<'tcx>,
 455         all_substs: SubstsRef<'tcx>,
 456     ) -> (ty::FnSig<'tcx>, ty::InstantiatedPredicates<'tcx>) {
 457         debug!("instantiate_method_sig(pick={:?}, all_substs={:?})", pick, all_substs);
 458
 459         // Instantiate the bounds on the method with the
 460         // type/early-bound-regions substitutions performed. There can
 461         // be no late-bound regions appearing here.
 462         let def_id = pick.item.def_id;
 463         let method_predicates = self.tcx.predicates_of(def_id).instantiate(self.tcx, all_substs);
 464
 465         debug!("method_predicates after subst = {:?}", method_predicates);
 466
 467         let sig = self.tcx.bound_fn_sig(def_id);
 468
 469         let sig = sig.subst(self.tcx, all_substs);
 470         debug!("type scheme substituted, sig={:?}", sig);
 471
 472         let sig = self.replace_bound_vars_with_fresh_vars(sig);
 473         debug!("late-bound lifetimes from method instantiated, sig={:?}", sig);
 474
 475         (sig, method_predicates)
 476     }
 477
 478     fn add_obligations(
 479         &mut self,
 480         fty: Ty<'tcx>,
 481         all_substs: SubstsRef<'tcx>,
 482         method_predicates: ty::InstantiatedPredicates<'tcx>,
 483         def_id: DefId,
 484     ) {
 485         debug!(
 486             "add_obligations: fty={:?} all_substs={:?} method_predicates={:?} def_id={:?}",
 487             fty, all_substs, method_predicates, def_id
 488         );
 489
 490         // FIXME: could replace with the following, but we already calculated `method_predicates`,
 491         // so we just call `predicates_for_generics` directly to avoid redoing work.
 492         // `self.add_required_obligations(self.span, def_id, &all_substs);`
 493         for obligation in traits::predicates_for_generics(
 494             |idx, span| {
 495                 let code = if span.is_dummy() {
 496                     ObligationCauseCode::ExprItemObligation(def_id, self.call_expr.hir_id, idx)
 497                 } else {
 498                     ObligationCauseCode::ExprBindingObligation(
 499                         def_id,
 500                         span,
 501                         self.call_expr.hir_id,
 502                         idx,
 503                     )
 504                 };
 505                 traits::ObligationCause::new(self.span, self.body_id, code)
 506             },
 507             self.param_env,
 508             method_predicates,
 509         ) {
 510             self.register_predicate(obligation);
 511         }
 512
 513         // this is a projection from a trait reference, so we have to
 514         // make sure that the trait reference inputs are well-formed.
 515         self.add_wf_bounds(all_substs, self.call_expr);
 516
 517         // the function type must also be well-formed (this is not
 518         // implied by the substs being well-formed because of inherent
 519         // impls and late-bound regions - see issue #28609).
 520         self.register_wf_obligation(fty.into(), self.span, traits::WellFormed(None));
 521     }
 522
 523     ///////////////////////////////////////////////////////////////////////////
 524     // MISCELLANY
 525
 526     fn predicates_require_illegal_sized_bound(
 527         &self,
 528         predicates: &ty::InstantiatedPredicates<'tcx>,
 529     ) -> Option<Span> {
 530         let sized_def_id = self.tcx.lang_items().sized_trait()?;
 531
 532         traits::elaborate_predicates(self.tcx, predicates.predicates.iter().copied())
 533             // We don't care about regions here.
 534             .filter_map(|obligation| match obligation.predicate.kind().skip_binder() {
 535                 ty::PredicateKind::Trait(trait_pred) if trait_pred.def_id() == sized_def_id => {
 536                     let span = iter::zip(&predicates.predicates, &predicates.spans)
 537                         .find_map(
 538                             |(p, span)| {
 539                                 if *p == obligation.predicate { Some(*span) } else { None }
 540                             },
 541                         )
 542                         .unwrap_or(rustc_span::DUMMY_SP);
 543                     Some((trait_pred, span))
 544                 }
 545                 _ => None,
 546             })
 547             .find_map(|(trait_pred, span)| match trait_pred.self_ty().kind() {
 548                 ty::Dynamic(..) => Some(span),
 549                 _ => None,
 550             })
 551     }
 552
 553     fn enforce_illegal_method_limitations(&self, pick: &probe::Pick<'_>) {
 554         // Disallow calls to the method `drop` defined in the `Drop` trait.
 555         if let Some(trait_def_id) = pick.item.trait_container(self.tcx) {
 556             callee::check_legal_trait_for_method_call(
 557                 self.tcx,
 558                 self.span,
 559                 Some(self.self_expr.span),
 560                 self.call_expr.span,
 561                 trait_def_id,
 562             )
 563         }
 564     }
 565
 566     fn upcast(
 567         &mut self,
 568         source_trait_ref: ty::PolyTraitRef<'tcx>,
 569         target_trait_def_id: DefId,
 570     ) -> ty::PolyTraitRef<'tcx> {
 571         let upcast_trait_refs =
 572             traits::upcast_choices(self.tcx, source_trait_ref, target_trait_def_id);
 573
 574         // must be exactly one trait ref or we'd get an ambig error etc
 575         if upcast_trait_refs.len() != 1 {
 576             span_bug!(
 577                 self.span,
 578                 "cannot uniquely upcast `{:?}` to `{:?}`: `{:?}`",
 579                 source_trait_ref,
 580                 target_trait_def_id,
 581                 upcast_trait_refs
 582             );
 583         }
 584
 585         upcast_trait_refs.into_iter().next().unwrap()
 586     }
 587
 588     fn replace_bound_vars_with_fresh_vars<T>(&self, value: ty::Binder<'tcx, T>) -> T
 589     where
 590         T: TypeFoldable<'tcx> + Copy,
 591     {
 592         self.fcx.replace_bound_vars_with_fresh_vars(self.span, infer::FnCall, value)
 593     }
 594 }