change definitely non-productive cycles to error

Author: lcnr

Diff for: 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)),

Diff for: compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -271,12 +271,38 @@ where
     /// and will need to clearly document it in the rustc-dev-guide before
     /// stabilization.
     pub(super) fn step_kind_for_source(&self, source: GoalSource) -> PathKind {
-        match (self.current_goal_kind, source) {
-            (_, GoalSource::NormalizeGoal(step_kind)) => step_kind,
-            (CurrentGoalKind::CoinductiveTrait, GoalSource::ImplWhereBound) => {
-                PathKind::Coinductive
+        match source {
+            // We treat these goals as unknown for now. It is likely that most, if not all
+            // miscellaneous nested goals will be converted to `GoalSource::MiscKnownInductive`
+            // over time.
+            GoalSource::Misc => PathKind::Unknown,
+            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.
+                //
+                // We probably want to make all traits coinductive in the future,
+                // so we treat cycles involving their where-clauses as ambiguous.
+                if let CurrentGoalKind::CoinductiveTrait = self.current_goal_kind {
+                    PathKind::Coinductive
+                } else {
+                    PathKind::Unknown
+                }
             }
-            _ => PathKind::Inductive,
+            // 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,
+            // A step which is clearly unproductive. Cycles exclusively involving such steps
+            // result in `Err(NoSolution)`.
+            GoalSource::MiscKnownInductive | GoalSource::InstantiateHigherRanked => {
+                PathKind::Inductive
+            }
+            // These goal sources are likely unproductive and can be changed to
+            // `PathKind::Inductive`. Keeping them as unknown until we're confident
+            // about this and have an example where it is necessary.
+            GoalSource::AliasBoundConstCondition | GoalSource::AliasWellFormed => PathKind::Unknown,
         }
     }
 
@@ -606,7 +632,7 @@ where
 
             let (NestedNormalizationGoals(nested_goals), _, certainty) = self.evaluate_goal_raw(
                 GoalEvaluationKind::Nested,
-                GoalSource::Misc,
+                GoalSource::normalizes_to(),
                 unconstrained_goal,
             )?;
             // Add the nested goals from normalization to our own nested goals.
@@ -683,7 +709,7 @@ where
     pub(super) fn add_normalizes_to_goal(&mut self, mut goal: Goal<I, ty::NormalizesTo<I>>) {
         goal.predicate = goal.predicate.fold_with(&mut ReplaceAliasWithInfer::new(
             self,
-            GoalSource::Misc,
+            GoalSource::normalizes_to(),
             goal.param_env,
         ));
         self.inspect.add_normalizes_to_goal(self.delegate, self.max_input_universe, goal);
@@ -939,7 +965,7 @@ where
         rhs: T,
     ) -> Result<(), NoSolution> {
         let goals = self.delegate.relate(param_env, lhs, variance, rhs, self.origin_span)?;
-        self.add_goals(GoalSource::Misc, goals);
+        self.add_goals(GoalSource::MiscKnownInductive, goals);
         Ok(())
     }
 

Diff for: compiler/rustc_next_trait_solver/src/solve/inspect/build.rs

@@ -421,7 +421,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
         self.add_goal(
             delegate,
             max_input_universe,
-            GoalSource::Misc,
+            GoalSource::normalizes_to(),
             goal.with(delegate.cx(), goal.predicate),
         );
     }

Diff for: compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -313,7 +313,7 @@ where
                     ty::AliasRelationDirection::Equate,
                 ),
             );
-            self.add_goal(GoalSource::Misc, alias_relate_goal);
+            self.add_goal(GoalSource::MiscKnownInductive, alias_relate_goal);
             self.try_evaluate_added_goals()?;
             Ok(self.resolve_vars_if_possible(normalized_term))
         } else {

Diff for: compiler/rustc_next_trait_solver/src/solve/project_goals.rs

@@ -24,7 +24,7 @@ where
                 ty::AliasRelationDirection::Equate,
             ),
         );
-        self.add_goal(GoalSource::Misc, goal);
+        self.add_goal(GoalSource::MiscKnownInductive, goal);
         self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
     }
 }

Diff for: compiler/rustc_next_trait_solver/src/solve/search_graph.rs

@@ -3,7 +3,7 @@ use std::marker::PhantomData;
 
 use rustc_type_ir::Interner;
 use rustc_type_ir::search_graph::{self, PathKind};
-use rustc_type_ir::solve::{CanonicalInput, Certainty, QueryResult};
+use rustc_type_ir::solve::{CanonicalInput, Certainty, NoSolution, QueryResult};
 
 use super::inspect::ProofTreeBuilder;
 use super::{FIXPOINT_STEP_LIMIT, has_no_inference_or_external_constraints};
@@ -47,7 +47,8 @@ where
     ) -> QueryResult<I> {
         match kind {
             PathKind::Coinductive => response_no_constraints(cx, input, Certainty::Yes),
-            PathKind::Inductive => response_no_constraints(cx, input, Certainty::overflow(false)),
+            PathKind::Unknown => response_no_constraints(cx, input, Certainty::overflow(false)),
+            PathKind::Inductive => Err(NoSolution),
         }
     }
 
@@ -57,12 +58,7 @@ where
         input: CanonicalInput<I>,
         result: QueryResult<I>,
     ) -> bool {
-        match kind {
-            PathKind::Coinductive => response_no_constraints(cx, input, Certainty::Yes) == result,
-            PathKind::Inductive => {
-                response_no_constraints(cx, input, Certainty::overflow(false)) == result
-            }
-        }
+        Self::initial_provisional_result(cx, kind, input) == result
     }
 
     fn on_stack_overflow(

Diff for: compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs

@@ -438,9 +438,15 @@ 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::NormalizeGoal(_),
+                    GoalSource::Misc
+                    | GoalSource::MiscKnownInductive
+                    | GoalSource::NormalizeGoal(_),
                 ) => {
                     continue;
                 }