Stop using translate_args in the new solver

Author: compiler-errors

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

@@ -12,7 +12,6 @@ use rustc_middle::bug;
 use rustc_middle::traits::solve::{
     inspect, CanonicalInput, CanonicalResponse, Certainty, PredefinedOpaquesData, QueryResult,
 };
-use rustc_middle::traits::specialization_graph;
 use rustc_middle::ty::AliasRelationDirection;
 use rustc_middle::ty::TypeFolder;
 use rustc_middle::ty::{
@@ -900,16 +899,6 @@ impl<'tcx> EvalCtxt<'_, InferCtxt<'tcx>> {
         args
     }
 
-    pub(super) fn translate_args(
-        &self,
-        param_env: ty::ParamEnv<'tcx>,
-        source_impl: DefId,
-        source_args: ty::GenericArgsRef<'tcx>,
-        target_node: specialization_graph::Node,
-    ) -> ty::GenericArgsRef<'tcx> {
-        crate::traits::translate_args(self.infcx, param_env, source_impl, source_args, target_node)
-    }
-
     pub(super) fn register_ty_outlives(&self, ty: Ty<'tcx>, lt: ty::Region<'tcx>) {
         self.infcx.register_region_obligation_with_cause(ty, lt, &ObligationCause::dummy());
     }

compiler/rustc_trait_selection/src/solve/normalizes_to/mod.rs

@@ -1,4 +1,4 @@
-use crate::traits::specialization_graph;
+use crate::traits::specialization_graph::{self, LeafDef, Node};
 
 use super::assembly::structural_traits::AsyncCallableRelevantTypes;
 use super::assembly::{self, structural_traits, Candidate};
@@ -9,7 +9,6 @@ use rustc_infer::infer::InferCtxt;
 use rustc_infer::traits::query::NoSolution;
 use rustc_infer::traits::solve::inspect::ProbeKind;
 use rustc_infer::traits::solve::MaybeCause;
-use rustc_infer::traits::specialization_graph::LeafDef;
 use rustc_infer::traits::Reveal;
 use rustc_middle::traits::solve::{CandidateSource, Certainty, Goal, QueryResult};
 use rustc_middle::traits::BuiltinImplSource;
@@ -235,14 +234,38 @@ impl<'tcx> assembly::GoalKind<'tcx> for NormalizesTo<'tcx> {
             //
             // And then map these args to the args of the defining impl of `Assoc`, going
             // from `[u32, u64]` to `[u32, i32, u64]`.
-            let impl_args_with_gat =
-                goal.predicate.alias.args.rebase_onto(tcx, goal_trait_ref.def_id, impl_args);
-            let args = ecx.translate_args(
-                goal.param_env,
-                impl_def_id,
-                impl_args_with_gat,
-                assoc_def.defining_node,
-            );
+            let args = match assoc_def.defining_node {
+                Node::Trait(_) => goal.predicate.alias.args,
+                Node::Impl(target_impl_def_id) => {
+                    let impl_args_with_gat = goal.predicate.alias.args.rebase_onto(
+                        tcx,
+                        goal_trait_ref.def_id,
+                        impl_args,
+                    );
+                    if target_impl_def_id == impl_def_id {
+                        // Same impl, no need to rebase.
+                        impl_args_with_gat
+                    } else {
+                        let target_args = ecx.fresh_args_for_item(target_impl_def_id);
+                        let target_trait_ref = tcx
+                            .impl_trait_ref(target_impl_def_id)
+                            .unwrap()
+                            .instantiate(tcx, target_args);
+                        // Relate source impl to target impl by equating trait refs.
+                        ecx.eq(goal.param_env, impl_trait_ref, target_trait_ref)?;
+                        // Also add predicates since they may be needed to constrain the
+                        // source impl's params.
+                        ecx.add_goals(
+                            GoalSource::Misc,
+                            tcx.predicates_of(target_impl_def_id)
+                                .instantiate(tcx, target_args)
+                                .into_iter()
+                                .map(|(pred, _)| goal.with(tcx, pred)),
+                        );
+                        impl_args_with_gat.rebase_onto(tcx, impl_def_id, target_args)
+                    }
+                }
+            };
 
             if !tcx.check_args_compatible(assoc_def.item.def_id, args) {
                 return error_response(

tests/ui/specialization/source-impl-requires-constraining-predicates.rs

@@ -0,0 +1,22 @@
+//@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
+// Tests that rebasing from the concrete impl to the default impl also processes the
+// `[u32; 0]: IntoIterator<Item = ?U>` predicate to constrain the `?U` impl arg.
+
+#![feature(specialization)]
+trait Spec {
+    type Assoc;
+}
+
+default impl<T, U> Spec for T where T: IntoIterator<Item = U> {
+    type Assoc = U;
+}
+
+impl<T> Spec for [T; 0] {}
+
+fn main() {
+    let x: <[u32; 0] as Spec>::Assoc = 1;
+}