Auto merge of #133502 - lcnr:rust4, r=<try>

[DO NOT MERGE] `-Znext-solver=globally` experiments

Author: rust-bors[bot]

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -653,10 +653,13 @@ fn check_new_solver_banned_features(sess: &Session, features: &Features) {
         .map(|feat| feat.attr_sp)
     {
         #[allow(rustc::symbol_intern_string_literal)]
-        sess.dcx().emit_err(errors::IncompatibleFeatures {
-            spans: vec![gce_span],
-            f1: Symbol::intern("-Znext-solver=globally"),
-            f2: sym::generic_const_exprs,
-        });
+        sess.dcx()
+            .create_fatal(errors::IncompatibleFeatures {
+                spans: vec![gce_span],
+                f1: Symbol::intern("-Znext-solver=globally"),
+                f2: sym::generic_const_exprs,
+            })
+            .with_code(rustc_errors::E0001)
+            .emit();
     }
 }

compiler/rustc_middle/src/ty/context.rs

@@ -3475,7 +3475,7 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     pub fn next_trait_solver_globally(self) -> bool {
-        self.sess.opts.unstable_opts.next_solver.globally
+        self.sess.opts.unstable_opts.next_solver.globally && !self.features().generic_const_exprs()
     }
 
     pub fn next_trait_solver_in_coherence(self) -> bool {

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -201,7 +201,7 @@ where
         span: I::Span,
         stalled_on: Option<GoalStalledOn<I>>,
     ) -> Result<GoalEvaluation<I>, NoSolution> {
-        EvalCtxt::enter_root(self, self.cx().recursion_limit(), span, |ecx| {
+        EvalCtxt::enter_root(self, self.cx().recursion_limit() * 2, span, |ecx| {
             ecx.evaluate_goal(GoalSource::Misc, goal, stalled_on)
         })
     }
@@ -1485,7 +1485,7 @@ pub fn evaluate_root_goal_for_proof_tree_raw_provider<
     let mut inspect = inspect::ProofTreeBuilder::new();
     let canonical_result = SearchGraph::<D>::evaluate_root_goal_for_proof_tree(
         cx,
-        cx.recursion_limit(),
+        cx.recursion_limit() * 2,
         canonical_goal,
         &mut inspect,
     );

compiler/rustc_session/src/config.rs

@@ -991,7 +991,7 @@ pub struct NextSolverConfig {
     pub coherence: bool = true,
     /// Whether the new trait solver should be enabled everywhere.
     /// This is only `true` if `coherence` is also enabled.
-    pub globally: bool = false,
+    pub globally: bool = true,
 }
 
 #[derive(Clone)]

compiler/rustc_type_ir/src/search_graph/mod.rs

@@ -916,10 +916,9 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
 /// heads from the stack. This may not necessarily mean that we've actually
 /// reached a fixpoint for that cycle head, which impacts the way we rebase
 /// provisional cache entries.
-#[derive_where(Debug; X: Cx)]
-enum RebaseReason<X: Cx> {
+#[derive(Debug)]
+enum RebaseReason {
     NoCycleUsages,
-    Ambiguity(X::AmbiguityInfo),
     Overflow,
     /// We've actually reached a fixpoint.
     ///
@@ -956,7 +955,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D, X> {
         &mut self,
         cx: X,
         stack_entry: &StackEntry<X>,
-        rebase_reason: RebaseReason<X>,
+        rebase_reason: RebaseReason,
     ) {
         let popped_head_index = self.stack.next_index();
         #[allow(rustc::potential_query_instability)]
@@ -1035,9 +1034,6 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D, X> {
                         // is not actually equal to the final provisional result. We
                         // need to discard the provisional cache entry in this case.
                         RebaseReason::NoCycleUsages => return false,
-                        RebaseReason::Ambiguity(info) => {
-                            *result = D::propagate_ambiguity(cx, input, info);
-                        }
                         RebaseReason::Overflow => *result = D::fixpoint_overflow_result(cx, input),
                         RebaseReason::ReachedFixpoint(None) => {}
                         RebaseReason::ReachedFixpoint(Some(path_kind)) => {
@@ -1352,27 +1348,6 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D, X> {
                 return EvaluationResult::finalize(stack_entry, encountered_overflow, result);
             }
 
-            // If computing this goal results in ambiguity with no constraints,
-            // we do not rerun it. It's incredibly difficult to get a different
-            // response in the next iteration in this case. These changes would
-            // likely either be caused by incompleteness or can change the maybe
-            // cause from ambiguity to overflow. Returning ambiguity always
-            // preserves soundness and completeness even if the goal is be known
-            // to succeed or fail.
-            //
-            // This prevents exponential blowup affecting multiple major crates.
-            // As we only get to this branch if we haven't yet reached a fixpoint,
-            // we also taint all provisional cache entries which depend on the
-            // current goal.
-            if let Some(info) = D::is_ambiguous_result(result) {
-                self.rebase_provisional_cache_entries(
-                    cx,
-                    &stack_entry,
-                    RebaseReason::Ambiguity(info),
-                );
-                return EvaluationResult::finalize(stack_entry, encountered_overflow, result);
-            };
-
             // If we've reached the fixpoint step limit, we bail with overflow and taint all
             // provisional cache entries which depend on the current goal.
             i += 1;

tests/ui/traits/next-solver/global-where-bound-normalization.rs

@@ -0,0 +1,45 @@
+//@ check-pass
+//@ compile-flags: -Znext-solver
+
+// Regression test for https://github.com/rust-lang/trait-system-refactor-initiative/issues/257.
+
+#![feature(rustc_attrs)]
+#![expect(internal_features)]
+#![rustc_no_implicit_bounds]
+
+pub trait Bound {}
+impl Bound for u8 {}
+
+pub trait Proj {
+    type Assoc;
+}
+impl<U: Bound> Proj for U {
+    type Assoc = U;
+}
+impl Proj for MyField {
+    type Assoc = u8;
+}
+
+// While wf-checking the global bounds of `fn foo`, elaborating this outlives predicate triggered a
+// cycle in the search graph along a particular probe path, which was not an actual solution.
+// That cycle then resulted in a forced false-positive ambiguity due to a performance hack in the
+// search graph and then ended up floundering the root goal evaluation.
+pub trait Field: Proj<Assoc: Bound + 'static> {}
+
+struct MyField;
+impl Field for MyField {}
+
+trait IdReqField {
+    type This;
+}
+impl<F: Field> IdReqField for F {
+    type This = F;
+}
+
+fn foo()
+where
+    <MyField as IdReqField>::This: Field,
+{
+}
+
+fn main() {}