Auto merge of #158643 - adwinwhite:rigid-param-env, r=<try>

Try to mark param env as rigid with the next solver

Author: bors

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -239,26 +239,21 @@ fn compare_method_predicate_entailment<'tcx>(
     let hybrid_preds = hybrid_preds.into_iter().map(Unnormalized::skip_norm_wip);
     let normalize_cause = traits::ObligationCause::misc(impl_m_span, impl_m_def_id);
     let param_env = ty::ParamEnv::new(tcx.mk_clauses_from_iter(hybrid_preds));
-    // FIXME(-Zhigher-ranked-assumptions): The `hybrid_preds`
+    // NOTE(-Zhigher-ranked-assumptions): The `hybrid_preds`
     // should be well-formed. However, using them may result in
     // region errors as we currently don't track placeholder
     // assumptions.
     //
-    // To avoid being backwards incompatible with the old solver,
-    // we also eagerly normalize the where-bounds in the new solver
-    // here while ignoring region constraints. This means we can then
-    // use where-bounds whose normalization results in placeholder
-    // errors further down without getting any errors.
+    // We eagerly normalize the where-clauses here while ignoring
+    // region constraints. This means we can then use where-bounds
+    // whose normalization results in placeholder errors further
+    // down without getting any errors.
     //
-    // It should be sound to do so as the only region errors here
+    // This should be sound to do so as the only region errors here
     // should be due to missing implied bounds.
     //
     // cc trait-system-refactor-initiative/issues/166.
-    let param_env = if tcx.next_trait_solver_globally() {
-        traits::deeply_normalize_param_env_ignoring_regions(tcx, param_env, normalize_cause)
-    } else {
-        traits::normalize_param_env_or_error(tcx, param_env, normalize_cause)
-    };
+    let param_env = traits::normalize_param_env_or_error(tcx, param_env, normalize_cause);
     debug!(caller_bounds=?param_env.caller_bounds());
 
     let infcx = &tcx.infer_ctxt().build(TypingMode::non_body_analysis());

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -298,7 +298,7 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
             self.param_env.caller_bounds().iter().filter_map(|predicate| {
                 match predicate.kind().skip_binder() {
                     ty::ClauseKind::Trait(data) if data.self_ty().is_param(index) => {
-                        Some((predicate, span))
+                        Some((ty::set_aliases_to_non_rigid(tcx, predicate).skip_norm_wip(), span))
                     }
                     _ => None,
                 }

compiler/rustc_infer/src/infer/outlives/test_type_match.rs

@@ -90,7 +90,8 @@ pub(super) fn can_match_erased_ty<'tcx>(
     // deal with rigid aliases, making sure we do so correctly
     // everywhere is effort, so we're just using `No` everywhere
     // for now. This should change soon.
-    let outlives_ty = ty::set_aliases_to_non_rigid(tcx, outlives_ty).skip_normalization();
+    let (outlives_ty, erased_ty) =
+        ty::set_aliases_to_non_rigid(tcx, (outlives_ty, erased_ty)).skip_normalization();
     if outlives_ty == erased_ty {
         // pointless micro-optimization
         true

compiler/rustc_infer/src/infer/outlives/verify.rs

@@ -258,6 +258,7 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
             let erased_p_ty = self.tcx.erase_and_anonymize_regions(
                 ty::set_aliases_to_non_rigid(self.tcx, p_ty).skip_norm_wip(),
             );
+            let erased_ty = ty::set_aliases_to_non_rigid(self.tcx, erased_ty).skip_norm_wip();
             (erased_p_ty == erased_ty).then_some(ty::Binder::dummy(ty::OutlivesPredicate(p_ty, r)))
         }));
 

compiler/rustc_middle/src/ty/context.rs

@@ -2699,6 +2699,10 @@ impl<'tcx> TyCtxt<'tcx> {
         self.sess.opts.unstable_opts.disable_fast_paths
     }
 
+    pub fn disable_param_env_hack(self) -> bool {
+        self.sess.opts.unstable_opts.disable_param_env_hack
+    }
+
     pub fn renormalize_rigid_aliases(self) -> bool {
         self.sess.opts.unstable_opts.renormalize_rigid_aliases
     }

compiler/rustc_session/src/options.rs

@@ -2351,6 +2351,8 @@ options! {
         "disable various performance optimizations in trait solving"),
     disable_incr_comp_backend_caching: bool = (false, parse_bool, [TRACKED],
         "disable caching of compiled objects by the codegen backend during incremental compilation"),
+    disable_param_env_hack: bool = (false, parse_bool, [TRACKED],
+        "do not try to mark param env as rigid for the next solver"),
     dual_proc_macros: bool = (false, parse_bool, [TRACKED],
         "load proc macros for both target and host, but only link to the target (default: no)"),
     dump_dep_graph: bool = (false, parse_bool, [UNTRACKED],

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -30,7 +30,6 @@ use rustc_errors::ErrorGuaranteed;
 pub use rustc_infer::traits::*;
 use rustc_macros::TypeVisitable;
 use rustc_middle::query::Providers;
-use rustc_middle::span_bug;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::{
     self, Clause, GenericArgs, GenericArgsRef, Ty, TyCtxt, TypeFoldable, TypeFolder,
@@ -250,19 +249,79 @@ fn pred_known_to_hold_modulo_regions<'tcx>(
     }
 }
 
+fn set_projection_term_to_non_rigid<'tcx, T: TypeFoldable<TyCtxt<'tcx>>>(
+    tcx: TyCtxt<'tcx>,
+    value: T,
+) -> T {
+    value.fold_with(&mut ProjectionTermToNonRigid { tcx })
+}
+
+struct ProjectionTermToNonRigid<'tcx> {
+    tcx: TyCtxt<'tcx>,
+}
+
+impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ProjectionTermToNonRigid<'tcx> {
+    fn cx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+
+    fn fold_predicate(&mut self, p: ty::Predicate<'tcx>) -> ty::Predicate<'tcx> {
+        if let ty::PredicateKind::Clause(clause) = p.kind().skip_binder()
+            && let ty::ClauseKind::Projection(projection_pred) = clause
+        {
+            p.kind()
+                .rebind(ty::ProjectionPredicate {
+                    projection_term: projection_pred.projection_term,
+                    term: ty::set_aliases_to_non_rigid(self.tcx, projection_pred.term)
+                        .skip_norm_wip(),
+                })
+                .upcast(self.tcx)
+        } else {
+            p
+        }
+    }
+}
+
+struct OpaqueToNonRigid<'tcx> {
+    tcx: TyCtxt<'tcx>,
+}
+
+impl<'tcx> TypeFolder<TyCtxt<'tcx>> for OpaqueToNonRigid<'tcx> {
+    fn cx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+
+    fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
+        if !(t.has_rigid_aliases() && t.has_opaque_types()) {
+            return t;
+        }
+
+        if let ty::Alias(ty::IsRigid::Yes, alias_ty @ ty::AliasTy { kind: ty::Opaque { .. }, .. }) =
+            t.kind()
+        {
+            let alias_ty = alias_ty.fold_with(self);
+            Ty::new_alias(self.tcx, ty::IsRigid::No, alias_ty)
+        } else {
+            t.super_fold_with(self)
+        }
+    }
+
+    fn fold_const(&mut self, c: ty::Const<'tcx>) -> ty::Const<'tcx> {
+        if c.has_rigid_aliases() && c.has_opaque_types() { c.super_fold_with(self) } else { c }
+    }
+
+    fn fold_predicate(&mut self, p: ty::Predicate<'tcx>) -> ty::Predicate<'tcx> {
+        if p.has_rigid_aliases() && p.has_opaque_types() { p.super_fold_with(self) } else { p }
+    }
+}
+
 #[instrument(level = "debug", skip(tcx, elaborated_env))]
 fn do_normalize_predicates<'tcx>(
     tcx: TyCtxt<'tcx>,
     cause: ObligationCause<'tcx>,
     elaborated_env: ty::ParamEnv<'tcx>,
     predicates: Vec<ty::Clause<'tcx>>,
 ) -> Result<Vec<ty::Clause<'tcx>>, ErrorGuaranteed> {
-    // Even if we move back to eager normalization elsewhere,
-    // param env normalization remains lazy in the next solver.
-    if tcx.next_trait_solver_globally() {
-        return Ok(predicates);
-    }
-
     // FIXME. We should really... do something with these region
     // obligations. But this call just continues the older
     // behavior (i.e., doesn't cause any new bugs), and it would
@@ -279,10 +338,30 @@ fn do_normalize_predicates<'tcx>(
     let span = cause.span;
     let infcx = tcx.infer_ctxt().ignoring_regions().build(TypingMode::non_body_analysis());
     let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
+    // FIXME: The `elaborated_env` is not really rigid. We do this to be
+    // consistent with the old solver. It fixes several issues with
+    // lazy norm of param env but unfix others.
+    let elaborated_env = if tcx.next_trait_solver_globally() && !tcx.disable_param_env_hack() {
+        // FIXME: combine them into one if the perf is bad.
+        let elaborated_env = ty::set_aliases_to_rigid(tcx, elaborated_env);
+        set_projection_term_to_non_rigid(tcx, elaborated_env)
+    } else {
+        elaborated_env
+    };
     let predicates = ocx.normalize(&cause, elaborated_env, Unnormalized::new_wip(predicates));
-    // FIXME: opaque types in param env might be in defining scope but we're
-    // using non body analysis for here. So the rigidness marker is wrong.
-    let predicates = ty::set_aliases_to_non_rigid(tcx, predicates).skip_norm_wip();
+    let predicates = if tcx.next_trait_solver_globally() {
+        if !tcx.disable_param_env_hack() {
+            let predicates = set_projection_term_to_non_rigid(tcx, predicates);
+            // FIXME(type_alias_impl_trait): opaque types in param env might be
+            // in defining scope but we're using non body analysis here.
+            // So the rigidness marker is wrong.
+            predicates.fold_with(&mut OpaqueToNonRigid { tcx })
+        } else {
+            ty::set_aliases_to_non_rigid(tcx, predicates).skip_norm_wip()
+        }
+    } else {
+        predicates
+    };
 
     let errors = ocx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
@@ -294,17 +373,20 @@ fn do_normalize_predicates<'tcx>(
 
     // We can use the `elaborated_env` here; the region code only
     // cares about declarations like `'a: 'b`.
+    //
     // FIXME: It's very weird that we ignore region obligations but apparently
     // still need to use `resolve_regions` as we need the resolved regions in
     // the normalized predicates.
-    let errors = infcx.resolve_regions(cause.body_id, elaborated_env, []);
-    if !errors.is_empty() {
-        tcx.dcx().span_delayed_bug(
-            span,
-            format!("failed region resolution while normalizing {elaborated_env:?}: {errors:?}"),
-        );
-    }
-
+    //
+    // FIXME(-Zhigher-ranked-assumptions): We're ignoring region errors for now.
+    // There're placeholder constraints `leaking` out. This is a hack to work around
+    // the fact that we don't support placeholder assumptions right now and is necessary
+    // for `compare_method_predicate_entailment`. We should remove this once we
+    // have proper support for implied bounds on binders.
+    //
+    // This is required by trait-system-refactor-initiative#166. The new solver encounters
+    // this more frequently as we entirely ignore outlives predicates with the old solver.
+    let _errors = infcx.resolve_regions(cause.body_id, elaborated_env, []);
     match infcx.fully_resolve(predicates) {
         Ok(predicates) => Ok(predicates),
         Err(fixup_err) => {
@@ -481,69 +563,6 @@ pub fn normalize_param_env_or_error<'tcx>(
     ty::ParamEnv::new(tcx.mk_clauses(&predicates))
 }
 
-/// Deeply normalize the param env using the next solver ignoring
-/// region errors.
-///
-/// FIXME(-Zhigher-ranked-assumptions): this is a hack to work around
-/// the fact that we don't support placeholder assumptions right now
-/// and is necessary for `compare_method_predicate_entailment`, see the
-/// use of this function for more info. We should remove this once we
-/// have proper support for implied bounds on binders.
-#[instrument(level = "debug", skip(tcx))]
-pub fn deeply_normalize_param_env_ignoring_regions<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    unnormalized_env: ty::ParamEnv<'tcx>,
-    cause: ObligationCause<'tcx>,
-) -> ty::ParamEnv<'tcx> {
-    let predicates: Vec<_> =
-        util::elaborate(tcx, unnormalized_env.caller_bounds().into_iter()).collect();
-
-    debug!("normalize_param_env_or_error: elaborated-predicates={:?}", predicates);
-
-    let elaborated_env = ty::ParamEnv::new(tcx.mk_clauses(&predicates));
-    if !elaborated_env.has_aliases() {
-        return elaborated_env;
-    }
-
-    let span = cause.span;
-    let infcx = tcx
-        .infer_ctxt()
-        .with_next_trait_solver(true)
-        .ignoring_regions()
-        .build(TypingMode::non_body_analysis());
-    let predicates = match crate::solve::deeply_normalize::<_, FulfillmentError<'tcx>>(
-        infcx.at(&cause, elaborated_env),
-        Unnormalized::new_wip(predicates),
-    ) {
-        Ok(predicates) => predicates,
-        Err(errors) => {
-            infcx.err_ctxt().report_fulfillment_errors(errors);
-            // An unnormalized env is better than nothing.
-            debug!("normalize_param_env_or_error: errored resolving predicates");
-            return elaborated_env;
-        }
-    };
-
-    debug!("do_normalize_predicates: normalized predicates = {:?}", predicates);
-    // FIXME(-Zhigher-ranked-assumptions): We're ignoring region errors for now.
-    // There're placeholder constraints `leaking` out.
-    // See the fixme in the enclosing function's docs for more.
-    let _errors = infcx.resolve_regions(cause.body_id, elaborated_env, []);
-
-    let predicates = match infcx.fully_resolve(predicates) {
-        Ok(predicates) => predicates,
-        Err(fixup_err) => {
-            span_bug!(
-                span,
-                "inference variables in normalized parameter environment: {}",
-                fixup_err
-            )
-        }
-    };
-    debug!("normalize_param_env_or_error: final predicates={:?}", predicates);
-    ty::ParamEnv::new(tcx.mk_clauses(&predicates))
-}
-
 #[derive(Debug)]
 pub enum EvaluateConstErr {
     /// The constant being evaluated was either a generic parameter or inference variable, *or*,

compiler/rustc_type_ir/src/fold.rs

@@ -563,12 +563,36 @@ where
         return ty::Unnormalized::new(value);
     }
 
-    let mut folder = RigidnessFolder { cx };
+    let mut folder = RigidnessFolder { cx, target_rigidness: ty::IsRigid::No };
     ty::Unnormalized::new(value.fold_with(&mut folder))
 }
 
+// FIXME: maybe take Unnormalizedas as input.
+pub fn set_aliases_to_rigid<I: Interner, T>(cx: I, value: T) -> T
+where
+    T: TypeFoldable<I>,
+{
+    if !value.has_non_rigid_aliases() {
+        return value;
+    }
+
+    let mut folder = RigidnessFolder { cx, target_rigidness: ty::IsRigid::Yes };
+    value.fold_with(&mut folder)
+}
+
+// Set all aliases to be rigid or non-rigid.
 struct RigidnessFolder<I: Interner> {
     cx: I,
+    target_rigidness: ty::IsRigid,
+}
+
+impl<I: Interner> RigidnessFolder<I> {
+    fn needs_change<T: TypeVisitable<I>>(&self, t: &T) -> bool {
+        match self.target_rigidness {
+            ty::IsRigid::Yes => t.has_non_rigid_aliases(),
+            ty::IsRigid::No => t.has_rigid_aliases(),
+        }
+    }
 }
 
 impl<I: Interner> TypeFolder<I> for RigidnessFolder<I> {
@@ -578,42 +602,42 @@ impl<I: Interner> TypeFolder<I> for RigidnessFolder<I> {
     }
 
     fn fold_binder<T: TypeFoldable<I>>(&mut self, t: ty::Binder<I, T>) -> ty::Binder<I, T> {
-        if t.has_rigid_aliases() { t.super_fold_with(self) } else { t }
+        if self.needs_change(&t) { t.super_fold_with(self) } else { t }
     }
 
     fn fold_ty(&mut self, t: I::Ty) -> I::Ty {
-        if !t.has_rigid_aliases() {
+        if !self.needs_change(&t) {
             return t;
         }
 
         match t.kind() {
-            ty::Alias(ty::IsRigid::Yes, alias_ty) => {
+            ty::Alias(is_rigid, alias_ty) if is_rigid != self.target_rigidness => {
                 let alias_ty = alias_ty.fold_with(self);
-                I::Ty::new_alias(self.cx(), ty::IsRigid::No, alias_ty)
+                I::Ty::new_alias(self.cx(), self.target_rigidness, alias_ty)
             }
             _ => t.super_fold_with(self),
         }
     }
 
     fn fold_const(&mut self, c: I::Const) -> I::Const {
-        if !c.has_rigid_aliases() {
+        if !self.needs_change(&c) {
             return c;
         }
 
         match c.kind() {
-            ty::ConstKind::Alias(ty::IsRigid::Yes, alias_const) => {
+            ty::ConstKind::Alias(is_rigid, alias_const) if is_rigid != self.target_rigidness => {
                 let alias_const = alias_const.fold_with(self);
-                I::Const::new_alias(self.cx, ty::IsRigid::No, alias_const)
+                I::Const::new_alias(self.cx, self.target_rigidness, alias_const)
             }
             _ => c.super_fold_with(self),
         }
     }
 
     fn fold_predicate(&mut self, p: I::Predicate) -> I::Predicate {
-        if p.has_rigid_aliases() { p.super_fold_with(self) } else { p }
+        if self.needs_change(&p) { p.super_fold_with(self) } else { p }
     }
 
     fn fold_clauses(&mut self, c: I::Clauses) -> I::Clauses {
-        if c.has_rigid_aliases() { c.super_fold_with(self) } else { c }
+        if self.needs_change(&c) { c.super_fold_with(self) } else { c }
     }
 }