gaming

Author: lcnr

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

@@ -740,7 +740,7 @@ where
                 // We skip the goal itself as that one would cycle.
                 let predicate: I::Predicate = trait_ref.upcast(cx);
                 ecx.add_goals(
-                    GoalSource::Misc,
+                    GoalSource::CoherenceUnknowableSuper,
                     elaborate::elaborate(cx, [predicate])
                         .skip(1)
                         .map(|predicate| goal.with(cx, predicate)),

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

@@ -262,9 +262,11 @@ where
         self.delegate.typing_mode()
     }
 
+    #[instrument(level = "trace", skip(self), ret)]
     pub(super) fn step_kind_for_source(&self, source: GoalSource) -> PathKind {
         match source {
-            GoalSource::ImplWhereBound | GoalSource::NormalizeImplWhereBound => {
+            GoalSource::NormalizeGoal(path_kind) => path_kind,
+            GoalSource::ImplWhereBound => {
                 // We currently only consider a cycle coinductive if it steps
                 // into a where-clause of a coinductive trait.
                 //
@@ -276,6 +278,11 @@ where
                     PathKind::Unknown
                 }
             }
+            // We treat checking super trait bounds for unknowable candidates as
+            // unknown. Treating them is inductive would cause be unsound as it causes
+            // tests/ui/traits/next-solver/coherence/ambiguity-causes-visitor-hang.rs
+            // to compile.
+            GoalSource::CoherenceUnknowableSuper => PathKind::Unknown,
             GoalSource::Misc
             | GoalSource::AliasBoundConstCondition
             | GoalSource::AliasWellFormed
@@ -1131,14 +1138,11 @@ where
         for_goal_source: GoalSource,
         param_env: I::ParamEnv,
     ) -> Self {
-        let normalization_goal_source = match for_goal_source {
-            GoalSource::ImplWhereBound => GoalSource::NormalizeImplWhereBound,
-            _ => GoalSource::Misc,
-        };
+        let step_kind = ecx.step_kind_for_source(for_goal_source);
         ReplaceAliasWithInfer {
             ecx,
             param_env,
-            normalization_goal_source,
+            normalization_goal_source: GoalSource::NormalizeGoal(step_kind),
             cache: Default::default(),
         }
     }

compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs

@@ -438,9 +438,13 @@ impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx> {
 
             let obligation;
             match (child_mode, nested_goal.source()) {
+                // We shouldn't really care about coherence unknowable candidates
+                // as we never report fulfillment errors involving them. However, this
+                // is still reachable when building the fulfillment errors.
+                (_, GoalSource::CoherenceUnknowableSuper) => continue,
                 (
                     ChildMode::Trait(_) | ChildMode::Host(_),
-                    GoalSource::Misc | GoalSource::NormalizeImplWhereBound,
+                    GoalSource::Misc | GoalSource::NormalizeGoal(_),
                 ) => {
                     continue;
                 }

compiler/rustc_type_ir/src/search_graph/mod.rs

@@ -20,6 +20,8 @@ use std::marker::PhantomData;
 
 use derive_where::derive_where;
 use rustc_index::{Idx, IndexVec};
+#[cfg(feature = "nightly")]
+use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
 use tracing::debug;
 
 use crate::data_structures::HashMap;
@@ -110,7 +112,8 @@ pub trait Delegate {
 /// In the initial iteration of a cycle, we do not yet have a provisional
 /// result. In the case we return an initial provisional result depending
 /// on the kind of cycle.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
 pub enum PathKind {
     /// A path consisting of only inductive/unproductive steps.
     Inductive,

compiler/rustc_type_ir/src/solve/mod.rs

@@ -8,6 +8,7 @@ use derive_where::derive_where;
 use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
 use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic};
 
+use crate::search_graph::PathKind;
 use crate::{self as ty, Canonical, CanonicalVarValues, Interner, Upcast};
 
 pub type CanonicalInput<I, T = <I as Interner>::Predicate> =
@@ -68,11 +69,6 @@ pub enum GoalSource {
     /// FIXME(-Znext-solver=coinductive): Explain how and why this
     /// changes whether cycles are coinductive.
     ImplWhereBound,
-    /// When eagerly replacing aliases with impl where-bounds, we also
-    /// have to consider these normalization goals to be coinductive.
-    ///
-    /// This is necessary for tests/ui/sized/coinductive-1.rs to compile.
-    NormalizeImplWhereBound,
     /// Const conditions that need to hold for `~const` alias bounds to hold.
     ///
     /// FIXME(-Znext-solver=coinductive): Are these even coinductive?
@@ -83,6 +79,17 @@ pub enum GoalSource {
     /// This is used in two places: projecting to an opaque whose hidden type
     /// is already registered in the opaque type storage, and for rigid projections.
     AliasWellFormed,
+    /// Proving super trait bounds while checking whether a trait or projection
+    /// goal is unknowable.
+    ///
+    /// We must not treat these as an inductive steps, see `EvalCtxt::step_kind_for_source`.
+    CoherenceUnknowableSuper,
+    /// In case normalizing aliases in nested goals cycles, eagerly normalizing these aliases
+    /// in the context of the parent may incorrectly change the cycle kind. Normalizing
+    /// aliases in goals therefore tracks the original path kind for this nested goal.
+    ///
+    /// This is necessary for tests/ui/sized/coinductive-1.rs to compile.
+    NormalizeGoal(PathKind),
 }
 
 #[derive_where(Clone; I: Interner, Goal<I, P>: Clone)]