Add new alias kind Ambiguous and renormalize instantiated binders

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -1082,7 +1082,12 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         let typeck_results = tcx.typeck(self.mir_def_id());
 
         // We don't use `ty.peel_refs()` to get the number of `*`s needed to get the root type.
-        let liberated_sig = tcx.liberate_late_bound_regions(closure_def_id.to_def_id(), args.sig());
+        let liberated_sig = tcx
+            .liberate_late_bound_regions(
+                closure_def_id.to_def_id(),
+                ty::Unnormalized::new_wip(args.sig()),
+            )
+            .skip_norm_wip();
         let mut peeled_ty = liberated_sig.output();
         let mut count = 0;
         while let ty::Ref(_, ref_ty, _) = *peeled_ty.kind() {

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -418,8 +418,9 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
 
         // Get the parent fn's signature with liberated late-bound regions,
         // so we have `ReLateParam` instead of `ReBound`.
-        let parent_fn_sig = tcx.fn_sig(parent_def_id).instantiate_identity().skip_norm_wip();
-        let liberated_sig = tcx.liberate_late_bound_regions(parent_def_id, parent_fn_sig);
+        let parent_fn_sig = tcx.fn_sig(parent_def_id).instantiate_identity();
+        let liberated_sig =
+            tcx.liberate_late_bound_regions(parent_def_id, parent_fn_sig).skip_norm_wip();
         let parent_param_ty = *liberated_sig.inputs().get(param_index)?;
 
         // Get the upvar's NLL type (with ReVar regions from renumbering).

compiler/rustc_borrowck/src/lib.rs

@@ -32,7 +32,8 @@ use rustc_index::bit_set::MixedBitSet;
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_infer::infer::outlives::env::RegionBoundPairs;
 use rustc_infer::infer::{
-    InferCtxt, NllRegionVariableOrigin, RegionVariableOrigin, TyCtxtInferExt,
+    BoundRegionConversionTime, InferCtxt, NllRegionVariableOrigin, RegionVariableOrigin,
+    TyCtxtInferExt,
 };
 use rustc_middle::mir::*;
 use rustc_middle::query::Providers;
@@ -707,6 +708,20 @@ impl<'tcx> BorrowckInferCtxt<'tcx> {
 
         next_region
     }
+
+    /// We expect all aliases to already be fully normalized during borrowck,
+    /// so we can redefine this method to just unwrap the unnormalized alias binder.
+    pub(crate) fn instantiate_binder_with_fresh_vars<T>(
+        &self,
+        span: Span,
+        lbrct: BoundRegionConversionTime,
+        value: ty::Binder<'tcx, T>,
+    ) -> T
+    where
+        T: TypeFoldable<TyCtxt<'tcx>> + Copy,
+    {
+        self.infcx.instantiate_binder_with_fresh_vars(span, lbrct, value).no_ambiguous_aliases()
+    }
 }
 
 impl<'tcx> Deref for BorrowckInferCtxt<'tcx> {

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -811,6 +811,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                         region_ctxt_fn,
                     )
                 });
+                let unnormalized_sig = unnormalized_sig.no_ambiguous_aliases();
                 debug!(?unnormalized_sig);
                 // IMPORTANT: We have to prove well formed for the function signature before
                 // we normalize it, as otherwise types like `<&'a &'b () as Trait>::Assoc`

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -173,7 +173,7 @@ impl<'a, 'b, 'tcx> NllTypeRelating<'a, 'b, 'tcx> {
         T: ty::TypeFoldable<TyCtxt<'tcx>> + Copy,
     {
         let value = if let Some(inner) = binder.no_bound_vars() {
-            inner
+            ty::UnnormalizedAmbiguous::dummy(inner)
         } else {
             let infcx = self.type_checker.infcx;
             let mut lazy_universe = None;
@@ -207,7 +207,7 @@ impl<'a, 'b, 'tcx> NllTypeRelating<'a, 'b, 'tcx> {
         };
 
         debug!(?value);
-        f(self, value)
+        f(self, value.no_ambiguous_aliases())
     }
 
     #[instrument(skip(self), level = "debug")]
@@ -245,7 +245,7 @@ impl<'a, 'b, 'tcx> NllTypeRelating<'a, 'b, 'tcx> {
         let replaced = infcx.tcx.replace_bound_vars_uncached(binder, delegate);
         debug!(?replaced);
 
-        replaced
+        replaced.no_ambiguous_aliases()
     }
 
     fn create_next_universe(&mut self) -> ty::UniverseIndex {

compiler/rustc_borrowck/src/universal_regions.rs

@@ -892,7 +892,7 @@ impl<'tcx> BorrowckInferCtxt<'tcx> {
                 ty::Region::new_late_param(self.tcx, all_outlive_scope.to_def_id(), kind);
             ty::Region::new_var(self.tcx, indices.to_region_vid(liberated_region))
         });
-        value
+        value.no_ambiguous_aliases()
     }
 }
 

compiler/rustc_codegen_ssa/src/base.rs

@@ -128,18 +128,15 @@ pub fn validate_trivial_unsize<'tcx>(
                 tcx.infer_ctxt().build_with_typing_env(ty::TypingEnv::fully_monomorphized());
             let universe = infcx.universe();
             let ocx = ObligationCtxt::new(&infcx);
-            infcx.enter_forall(hr_target_principal, |target_principal| {
-                let source_principal = infcx.instantiate_binder_with_fresh_vars(
-                    DUMMY_SP,
+            let cause = ObligationCause::dummy();
+            ocx.enter_forall(&cause, param_env, hr_target_principal, |target_principal| {
+                let source_principal = ocx.instantiate_binder_with_fresh_vars(
+                    &cause,
                     BoundRegionConversionTime::HigherRankedType,
+                    param_env,
                     hr_source_principal,
                 );
-                let Ok(()) = ocx.eq(
-                    &ObligationCause::dummy(),
-                    param_env,
-                    target_principal,
-                    source_principal,
-                ) else {
+                let Ok(()) = ocx.eq(&cause, param_env, target_principal, source_principal) else {
                     return false;
                 };
                 if !ocx.evaluate_obligations_error_on_ambiguity().is_empty() {

compiler/rustc_const_eval/src/util/type_name.rs

@@ -45,7 +45,7 @@ impl<'tcx> Printer<'tcx> for TypeNamePrinter<'tcx> {
             | ty::UnsafeBinder(_) => self.pretty_print_type(ty),
 
             // Placeholders (all printed as `_` to uniformize them).
-            ty::Param(_) | ty::Bound(..) | ty::Placeholder(_) | ty::Infer(_) | ty::Error(_) => {
+            ty::Param(_) | ty::Bound(..) | ty::Placeholder(_) | ty::Error(_) => {
                 write!(self, "_")?;
                 Ok(())
             }
@@ -63,13 +63,12 @@ impl<'tcx> Printer<'tcx> for TypeNamePrinter<'tcx> {
             | ty::Coroutine(def_id, args) => self.print_def_path(def_id, args),
             ty::Foreign(def_id) => self.print_def_path(def_id, &[]),
 
-            ty::Alias(ty::AliasTy { kind: ty::Free { .. }, .. }) => {
-                bug!("type_name: unexpected free alias")
-            }
-            ty::Alias(ty::AliasTy { kind: ty::Inherent { .. }, .. }) => {
-                bug!("type_name: unexpected inherent projection")
-            }
-            ty::CoroutineWitness(..) => bug!("type_name: unexpected `CoroutineWitness`"),
+            ty::Infer(_)
+            | ty::Alias(ty::AliasTy {
+                kind: ty::Free { .. } | ty::Inherent { .. } | ty::Ambiguous,
+                ..
+            })
+            | ty::CoroutineWitness(..) => bug!("type_name: unexpected type: {ty:?}"),
         }
     }
 

compiler/rustc_hir_analysis/src/check/compare_eii.rs

@@ -68,25 +68,22 @@ pub(crate) fn compare_eii_function_types<'tcx>(
     let mut wf_tys = FxIndexSet::default();
     let norm_cause = ObligationCause::misc(external_impl_span, external_impl);
 
-    let declaration_sig = tcx.fn_sig(foreign_item).instantiate_identity().skip_norm_wip();
-    let declaration_sig = tcx.liberate_late_bound_regions(external_impl.into(), declaration_sig);
+    let declaration_sig = tcx.fn_sig(foreign_item).instantiate_identity();
+    let declaration_sig =
+        tcx.liberate_late_bound_regions(external_impl.into(), declaration_sig).skip_norm_wip();
     debug!(?declaration_sig);
 
-    let unnormalized_external_impl_sig = infcx.instantiate_binder_with_fresh_vars(
+    // We need to check wf of the unnormalized sig.
+    let unnormalized_external_impl_sig = infcx.instantiate_unnormalized_binder_with_fresh_vars(
         external_impl_span,
         infer::BoundRegionConversionTime::HigherRankedType,
-        tcx.fn_sig(external_impl)
-            .instantiate(
-                tcx,
-                infcx.fresh_args_for_item(external_impl_span, external_impl.to_def_id()),
-            )
-            .skip_norm_wip(),
-    );
-    let external_impl_sig = ocx.normalize(
-        &norm_cause,
-        param_env,
-        Unnormalized::new_wip(unnormalized_external_impl_sig),
+        tcx.fn_sig(external_impl).instantiate(
+            tcx,
+            infcx.fresh_args_for_item(external_impl_span, external_impl.to_def_id()),
+        ),
     );
+    let external_impl_sig = ocx.normalize(&norm_cause, param_env, unnormalized_external_impl_sig);
+
     debug!(?external_impl_sig);
 
     // Next, add all inputs and output as well-formed tys. Importantly,
@@ -125,7 +122,7 @@ pub(crate) fn compare_eii_function_types<'tcx>(
     }
 
     if !(declaration_sig, external_impl_sig).references_error() {
-        for ty in unnormalized_external_impl_sig.inputs_and_output {
+        for ty in unnormalized_external_impl_sig.skip_normalization().inputs_and_output {
             ocx.register_obligation(traits::Obligation::new(
                 infcx.tcx,
                 cause.clone(),

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -326,19 +326,20 @@ fn compare_method_predicate_entailment<'tcx>(
 
     let mut wf_tys = FxIndexSet::default();
 
-    let unnormalized_impl_sig = infcx.instantiate_binder_with_fresh_vars(
+    // We need to check wf of unnormalized sig.
+    let unnormalized_impl_sig = infcx.instantiate_unnormalized_binder_with_fresh_vars(
         impl_m_span,
         BoundRegionConversionTime::HigherRankedType,
-        tcx.fn_sig(impl_m.def_id).instantiate_identity().skip_norm_wip(),
+        tcx.fn_sig(impl_m.def_id).instantiate_identity(),
     );
 
     let norm_cause = ObligationCause::misc(impl_m_span, impl_m_def_id);
-    let impl_sig =
-        ocx.normalize(&norm_cause, param_env, Unnormalized::new_wip(unnormalized_impl_sig));
+    let impl_sig = ocx.normalize(&norm_cause, param_env, unnormalized_impl_sig);
+
     debug!(?impl_sig);
 
-    let trait_sig = tcx.fn_sig(trait_m.def_id).instantiate(tcx, trait_to_impl_args).skip_norm_wip();
-    let trait_sig = tcx.liberate_late_bound_regions(impl_m.def_id, trait_sig);
+    let trait_sig = tcx.fn_sig(trait_m.def_id).instantiate(tcx, trait_to_impl_args);
+    let trait_sig = tcx.liberate_late_bound_regions(impl_m.def_id, trait_sig).skip_norm_wip();
 
     // Next, add all inputs and output as well-formed tys. Importantly,
     // we have to do this before normalization, since the normalized ty may
@@ -375,7 +376,7 @@ fn compare_method_predicate_entailment<'tcx>(
     }
 
     if !(impl_sig, trait_sig).references_error() {
-        for ty in unnormalized_impl_sig.inputs_and_output {
+        for ty in unnormalized_impl_sig.skip_normalization().inputs_and_output {
             ocx.register_obligation(traits::Obligation::new(
                 infcx.tcx,
                 cause.clone(),
@@ -534,15 +535,12 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
 
     // Normalize the impl signature with fresh variables for lifetime inference.
     let misc_cause = ObligationCause::misc(return_span, impl_m_def_id);
-    let impl_sig = ocx.normalize(
-        &misc_cause,
-        param_env,
-        Unnormalized::new_wip(infcx.instantiate_binder_with_fresh_vars(
-            return_span,
-            BoundRegionConversionTime::HigherRankedType,
-            tcx.fn_sig(impl_m.def_id).instantiate_identity().skip_norm_wip(),
-        )),
+    let impl_sig = infcx.instantiate_unnormalized_binder_with_fresh_vars(
+        return_span,
+        BoundRegionConversionTime::HigherRankedType,
+        tcx.fn_sig(impl_m.def_id).instantiate_identity(),
     );
+    let impl_sig = ocx.normalize(&misc_cause, param_env, impl_sig);
     impl_sig.error_reported()?;
     let impl_return_ty = impl_sig.output();
 
@@ -554,8 +552,9 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
     let unnormalized_trait_sig = tcx
         .liberate_late_bound_regions(
             impl_m.def_id,
-            tcx.fn_sig(trait_m.def_id).instantiate(tcx, trait_to_impl_args).skip_norm_wip(),
+            tcx.fn_sig(trait_m.def_id).instantiate(tcx, trait_to_impl_args),
         )
+        .skip_norm_wip()
         .fold_with(&mut collector);
 
     let trait_sig =
@@ -1259,12 +1258,12 @@ fn check_region_late_boundedness<'tcx>(
         .build_with_typing_env(ty::TypingEnv::non_body_analysis(tcx, impl_m.def_id));
 
     let impl_m_args = infcx.fresh_args_for_item(DUMMY_SP, impl_m.def_id);
-    let impl_m_sig = tcx.fn_sig(impl_m.def_id).instantiate(tcx, impl_m_args).skip_norm_wip();
-    let impl_m_sig = tcx.liberate_late_bound_regions(impl_m.def_id, impl_m_sig);
+    let impl_m_sig = tcx.fn_sig(impl_m.def_id).instantiate(tcx, impl_m_args);
+    let impl_m_sig = tcx.liberate_late_bound_regions(impl_m.def_id, impl_m_sig).skip_norm_wip();
 
     let trait_m_args = infcx.fresh_args_for_item(DUMMY_SP, trait_m.def_id);
-    let trait_m_sig = tcx.fn_sig(trait_m.def_id).instantiate(tcx, trait_m_args).skip_norm_wip();
-    let trait_m_sig = tcx.liberate_late_bound_regions(impl_m.def_id, trait_m_sig);
+    let trait_m_sig = tcx.fn_sig(trait_m.def_id).instantiate(tcx, trait_m_args);
+    let trait_m_sig = tcx.liberate_late_bound_regions(impl_m.def_id, trait_m_sig).skip_norm_wip();
 
     let ocx = ObligationCtxt::new(&infcx);
 
@@ -1515,11 +1514,12 @@ fn compare_self_type<'tcx>(
             }
             ty::AssocContainer::Trait => tcx.types.self_param,
         };
-        let self_arg_ty = tcx.fn_sig(method.def_id).instantiate_identity().skip_norm_wip().input(0);
+        let self_arg_ty = tcx.fn_sig(method.def_id).instantiate_identity().map(|sig| sig.input(0));
         let (infcx, param_env) = tcx
             .infer_ctxt()
             .build_with_typing_env(ty::TypingEnv::non_body_analysis(tcx, method.def_id));
-        let self_arg_ty = tcx.liberate_late_bound_regions(method.def_id, self_arg_ty);
+        let self_arg_ty =
+            tcx.liberate_late_bound_regions(method.def_id, self_arg_ty).skip_norm_wip();
         let can_eq_self = |ty| infcx.can_eq(param_env, untransformed_self_ty, ty);
         get_self_string(self_arg_ty, can_eq_self)
     };

compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs

@@ -44,23 +44,23 @@ pub(crate) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
     let impl_def_id = impl_m.container_id(tcx);
     let impl_m_args = ty::GenericArgs::identity_for_item(tcx, impl_m.def_id);
     let trait_m_to_impl_m_args = impl_m_args.rebase_onto(tcx, impl_def_id, impl_trait_ref.args);
-    let bound_trait_m_sig =
-        tcx.fn_sig(trait_m.def_id).instantiate(tcx, trait_m_to_impl_m_args).skip_norm_wip();
-    let trait_m_sig = tcx.liberate_late_bound_regions(impl_m.def_id, bound_trait_m_sig);
+    let bound_trait_m_sig = tcx.fn_sig(trait_m.def_id).instantiate(tcx, trait_m_to_impl_m_args);
+    let trait_m_sig =
+        tcx.liberate_late_bound_regions(impl_m.def_id, bound_trait_m_sig).skip_norm_wip();
     // replace the self type of the trait ref with `Self` so that diagnostics render better.
-    let trait_m_sig_with_self_for_diag = tcx.liberate_late_bound_regions(
-        impl_m.def_id,
-        tcx.fn_sig(trait_m.def_id)
-            .instantiate(
+    let trait_m_sig_with_self_for_diag = tcx
+        .liberate_late_bound_regions(
+            impl_m.def_id,
+            tcx.fn_sig(trait_m.def_id).instantiate(
                 tcx,
                 tcx.mk_args_from_iter(
                     [tcx.types.self_param.into()]
                         .into_iter()
                         .chain(trait_m_to_impl_m_args.iter().skip(1)),
                 ),
-            )
-            .skip_norm_wip(),
-    );
+            ),
+        )
+        .skip_norm_wip();
 
     let Ok(hidden_tys) = tcx.collect_return_position_impl_trait_in_trait_tys(impl_m.def_id) else {
         // Error already emitted, no need to delay another.

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -538,8 +538,9 @@ fn suggestion_signature<'tcx>(
             tcx,
             tcx.liberate_late_bound_regions(
                 assoc.def_id,
-                tcx.fn_sig(assoc.def_id).instantiate(tcx, args).skip_norm_wip(),
-            ),
+                tcx.fn_sig(assoc.def_id).instantiate(tcx, args),
+            )
+            .skip_norm_wip(),
             assoc.ident(tcx),
             tcx.predicates_of(assoc.def_id)
                 .instantiate_own(tcx, args)