Remove the NormalizesTo/Projection split

compiler/rustc_hir_typeck/src/fn_ctxt/inspect_obligations.rs

@@ -39,6 +39,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 self.type_matches_expected_vid(expected_vid, data.self_ty())
             }
             ty::PredicateKind::Clause(ty::ClauseKind::Projection(data)) => {
+                if !matches!(
+                    data.projection_term.kind(self.tcx),
+                    ty::AliasTermKind::ProjectionTy
+                        | ty::AliasTermKind::ProjectionConst
+                        | ty::AliasTermKind::InherentTy
+                        | ty::AliasTermKind::InherentConst
+                ) {
+                    return false;
+                }
+
                 self.type_matches_expected_vid(expected_vid, data.projection_term.self_ty())
             }
             ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(..))

compiler/rustc_next_trait_solver/src/canonical/mod.rs

@@ -97,13 +97,19 @@ pub(super) fn instantiate_and_apply_query_response<D, I>(
     original_values: &[I::GenericArg],
     response: CanonicalResponse<I>,
     span: I::Span,
+    prev_universe: ty::UniverseIndex,
 ) -> (NestedNormalizationGoals<I>, Certainty)
 where
     D: SolverDelegate<Interner = I>,
     I: Interner,
 {
-    let instantiation =
-        compute_query_response_instantiation_values(delegate, &original_values, &response, span);
+    let instantiation = compute_query_response_instantiation_values(
+        delegate,
+        &original_values,
+        &response,
+        span,
+        prev_universe,
+    );
 
     let Response { var_values, external_constraints, certainty } =
         delegate.instantiate_canonical(response, instantiation);
@@ -127,6 +133,7 @@ fn compute_query_response_instantiation_values<D, I, T>(
     original_values: &[I::GenericArg],
     response: &Canonical<I, T>,
     span: I::Span,
+    prev_universe: ty::UniverseIndex,
 ) -> CanonicalVarValues<I>
 where
     D: SolverDelegate<Interner = I>,
@@ -136,7 +143,6 @@ where
     // FIXME: Longterm canonical queries should deal with all placeholders
     // created inside of the query directly instead of returning them to the
     // caller.
-    let prev_universe = delegate.universe();
     let universes_created_in_query = response.max_universe.index();
     for _ in 0..universes_created_in_query {
         delegate.create_next_universe();
@@ -328,8 +334,13 @@ where
             .map(|&arg| delegate.fresh_var_for_kind_with_span(arg, span)),
     );
 
-    let instantiation =
-        compute_query_response_instantiation_values(delegate, orig_values, &state, span);
+    let instantiation = compute_query_response_instantiation_values(
+        delegate,
+        orig_values,
+        &state,
+        span,
+        delegate.universe(),
+    );
 
     let inspect::State { var_values, data } = delegate.instantiate_canonical(state, instantiation);
 

compiler/rustc_next_trait_solver/src/solve/alias_relate.rs

@@ -52,7 +52,13 @@ where
             let term = self.next_term_infer_of_kind(lhs);
             self.add_goal(
                 GoalSource::TypeRelating,
-                goal.with(cx, ty::NormalizesTo { alias, term }),
+                goal.with(
+                    cx,
+                    ty::ClauseKind::Projection(ty::ProjectionPredicate {
+                        projection_term: alias,
+                        term,
+                    }),
+                ),
             );
             term
         } else {
@@ -64,7 +70,13 @@ where
             let term = self.next_term_infer_of_kind(rhs);
             self.add_goal(
                 GoalSource::TypeRelating,
-                goal.with(cx, ty::NormalizesTo { alias, term }),
+                goal.with(
+                    cx,
+                    ty::ClauseKind::Projection(ty::ProjectionPredicate {
+                        projection_term: alias,
+                        term,
+                    }),
+                ),
             );
             term
         } else {

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

@@ -40,7 +40,7 @@ mod probe;
 /// This has effects on cycle handling handling and on how we compute
 /// query responses, see the variant descriptions for more info.
 #[derive(Debug, Copy, Clone)]
-enum CurrentGoalKind {
+pub(super) enum CurrentGoalKind {
     Misc,
     /// We're proving an trait goal for a coinductive trait, either an auto trait or `Sized`.
     ///
@@ -93,15 +93,15 @@ where
     /// If some `InferCtxt` method is missing, please first think defensively about
     /// the method's compatibility with this solver, or if an existing one does
     /// the job already.
-    delegate: &'a D,
+    pub(super) delegate: &'a D,
 
     /// The variable info for the `var_values`, only used to make an ambiguous response
     /// with no constraints.
-    var_kinds: I::CanonicalVarKinds,
+    pub(super) var_kinds: I::CanonicalVarKinds,
 
     /// What kind of goal we're currently computing, see the enum definition
     /// for more info.
-    current_goal_kind: CurrentGoalKind,
+    pub(super) current_goal_kind: CurrentGoalKind,
     pub(super) var_values: CanonicalVarValues<I>,
 
     /// The highest universe index nameable by the caller.
@@ -486,6 +486,7 @@ where
             &orig_values,
             response,
             self.origin_span,
+            self.delegate.universe(),
         );
 
         // FIXME: We previously had an assert here that checked that recomputing
@@ -564,7 +565,7 @@ where
     pub(super) fn compute_goal(&mut self, goal: Goal<I, I::Predicate>) -> QueryResult<I> {
         let Goal { param_env, predicate } = goal;
         let kind = predicate.kind();
-        self.enter_forall(kind, |ecx, kind| match kind {
+        let resp = self.enter_forall(kind, |ecx, kind| match kind {
             ty::PredicateKind::Clause(ty::ClauseKind::Trait(predicate)) => {
                 ecx.compute_trait_goal(Goal { param_env, predicate }).map(|(r, _via)| r)
             }
@@ -604,16 +605,18 @@ where
             ty::PredicateKind::ConstEquate(_, _) => {
                 panic!("ConstEquate should not be emitted when `-Znext-solver` is active")
             }
-            ty::PredicateKind::NormalizesTo(predicate) => {
-                ecx.compute_normalizes_to_goal(Goal { param_env, predicate })
+            ty::PredicateKind::NormalizesTo(_) => {
+                unreachable!()
             }
             ty::PredicateKind::AliasRelate(lhs, rhs, direction) => {
                 ecx.compute_alias_relate_goal(Goal { param_env, predicate: (lhs, rhs, direction) })
             }
             ty::PredicateKind::Ambiguous => {
                 ecx.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
             }
-        })
+        })?;
+        debug_assert!(resp.value.external_constraints.normalization_nested_goals.is_empty());
+        Ok(resp)
     }
 
     // Recursively evaluates all the goals added to this `EvalCtxt` to completion, returning
@@ -806,6 +809,7 @@ where
     ///
     /// This is the case if the `term` does not occur in any other part of the predicate
     /// and is able to name all other placeholder and inference variables.
+    #[allow(unused)]
     #[instrument(level = "trace", skip(self), ret)]
     pub(super) fn term_is_fully_unconstrained(&self, goal: Goal<I, ty::NormalizesTo<I>>) -> bool {
         let universe_of_term = match goal.predicate.term.kind() {
@@ -832,6 +836,7 @@ where
             cache: HashSet<I::Ty>,
         }
 
+        #[allow(unused)]
         impl<D: SolverDelegate<Interner = I>, I: Interner> ContainsTermOrNotNameable<'_, D, I> {
             fn check_nameable(&self, universe: ty::UniverseIndex) -> ControlFlow<()> {
                 if self.universe_of_term.can_name(universe) {
@@ -1423,16 +1428,15 @@ where
 
     fn fold_ty(&mut self, ty: I::Ty) -> I::Ty {
         match ty.kind() {
-            ty::Alias(..) if !ty.has_escaping_bound_vars() => {
+            ty::Alias(_, alias) if !ty.has_escaping_bound_vars() => {
                 let infer_ty = self.ecx.next_ty_infer();
-                let normalizes_to = ty::PredicateKind::AliasRelate(
-                    ty.into(),
-                    infer_ty.into(),
-                    ty::AliasRelationDirection::Equate,
-                );
+                let projection = ty::ClauseKind::Projection(ty::ProjectionPredicate {
+                    projection_term: alias.into(),
+                    term: infer_ty.into(),
+                });
                 self.ecx.add_goal(
                     self.normalization_goal_source,
-                    Goal::new(self.cx(), self.param_env, normalizes_to),
+                    Goal::new(self.cx(), self.param_env, projection),
                 );
                 infer_ty
             }
@@ -1452,16 +1456,15 @@ where
 
     fn fold_const(&mut self, ct: I::Const) -> I::Const {
         match ct.kind() {
-            ty::ConstKind::Unevaluated(..) if !ct.has_escaping_bound_vars() => {
+            ty::ConstKind::Unevaluated(uc) if !ct.has_escaping_bound_vars() => {
                 let infer_ct = self.ecx.next_const_infer();
-                let normalizes_to = ty::PredicateKind::AliasRelate(
-                    ct.into(),
-                    infer_ct.into(),
-                    ty::AliasRelationDirection::Equate,
-                );
+                let projection = ty::ClauseKind::Projection(ty::ProjectionPredicate {
+                    projection_term: uc.into(),
+                    term: infer_ct.into(),
+                });
                 self.ecx.add_goal(
                     self.normalization_goal_source,
-                    Goal::new(self.cx(), self.param_env, normalizes_to),
+                    Goal::new(self.cx(), self.param_env, projection),
                 );
                 infer_ct
             }
@@ -1528,6 +1531,7 @@ pub(super) fn evaluate_root_goal_for_proof_tree<D: SolverDelegate<Interner = I>,
         &proof_tree.orig_values,
         response,
         origin_span,
+        delegate.universe(),
     );
 
     (Ok(normalization_nested_goals), proof_tree)

compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -16,7 +16,6 @@ mod assembly;
 mod effect_goals;
 mod eval_ctxt;
 pub mod inspect;
-mod normalizes_to;
 mod project_goals;
 mod search_graph;
 mod trait_goals;

compiler/rustc_next_trait_solver/src/solve/normalizes_to/anon_const.rs → compiler/rustc_next_trait_solver/src/solve/project_goals/anon_const.rs

@@ -12,10 +12,11 @@ where
     #[instrument(level = "trace", skip(self), ret)]
     pub(super) fn normalize_anon_const(
         &mut self,
-        goal: Goal<I, ty::NormalizesTo<I>>,
+        goal: Goal<I, ty::ProjectionPredicate<I>>,
     ) -> QueryResult<I> {
         if self.typing_mode() == TypingMode::Coherence
-            && self.cx().anon_const_kind(goal.predicate.alias.def_id) == ty::AnonConstKind::OGCA
+            && self.cx().anon_const_kind(goal.predicate.projection_term.def_id)
+                == ty::AnonConstKind::OGCA
         {
             // During coherence, OGCA consts should be normalized ambiguously
             // because they are opaque but eventually resolved to a real value.
@@ -28,11 +29,11 @@ where
         } else if let Some(normalized_const) = self.evaluate_const(
             goal.param_env,
             ty::UnevaluatedConst::new(
-                goal.predicate.alias.def_id.try_into().unwrap(),
-                goal.predicate.alias.args,
+                goal.predicate.projection_term.def_id.try_into().unwrap(),
+                goal.predicate.projection_term.args,
             ),
         ) {
-            self.instantiate_normalizes_to_term(goal, normalized_const.into());
+            self.instantiate_projection_term(goal, normalized_const.into())?;
             self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
         } else {
             self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)

compiler/rustc_next_trait_solver/src/solve/normalizes_to/free_alias.rs → compiler/rustc_next_trait_solver/src/solve/project_goals/free_alias.rs

@@ -16,10 +16,10 @@ where
 {
     pub(super) fn normalize_free_alias(
         &mut self,
-        goal: Goal<I, ty::NormalizesTo<I>>,
+        goal: Goal<I, ty::ProjectionPredicate<I>>,
     ) -> QueryResult<I> {
         let cx = self.cx();
-        let free_alias = goal.predicate.alias;
+        let free_alias = goal.predicate.projection_term;
 
         // Check where clauses
         self.add_goals(
@@ -35,7 +35,7 @@ where
             cx.const_of_item(free_alias.def_id).instantiate(cx, free_alias.args).into()
         };
 
-        self.instantiate_normalizes_to_term(goal, actual);
+        self.instantiate_projection_term(goal, actual)?;
         self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
     }
 }

compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs → compiler/rustc_next_trait_solver/src/solve/project_goals/inherent.rs

@@ -17,10 +17,10 @@ where
 {
     pub(super) fn normalize_inherent_associated_term(
         &mut self,
-        goal: Goal<I, ty::NormalizesTo<I>>,
+        goal: Goal<I, ty::ProjectionPredicate<I>>,
     ) -> QueryResult<I> {
         let cx = self.cx();
-        let inherent = goal.predicate.alias;
+        let inherent = goal.predicate.projection_term;
 
         let impl_def_id = cx.parent(inherent.def_id);
         let impl_args = self.fresh_args_for_item(impl_def_id);
@@ -56,7 +56,7 @@ where
         } else {
             cx.const_of_item(inherent.def_id).instantiate(cx, inherent_args).into()
         };
-        self.instantiate_normalizes_to_term(goal, normalized);
+        self.instantiate_projection_term(goal, normalized)?;
         self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
     }
 }