Dejargnonize subst

compiler/rustc_trait_selection/src/solve/assembly/structural_traits.rs

@@ -576,7 +576,7 @@ pub(in crate::solve) fn predicates_for_object_candidate<'tcx>(
             assert_eq!(
                 old_ty,
                 None,
-                "{} has two substitutions: {} and {}",
+                "{} has two generic parameters: {} and {}",
                 proj.projection_ty,
                 proj.term,
                 old_ty.unwrap()

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

@@ -192,11 +192,14 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
         original_values: Vec<ty::GenericArg<'tcx>>,
         response: CanonicalResponse<'tcx>,
     ) -> Result<(Certainty, Vec<Goal<'tcx, ty::Predicate<'tcx>>>), NoSolution> {
-        let substitution =
-            Self::compute_query_response_substitution(self.infcx, &original_values, &response);
+        let instantiation = Self::compute_query_response_instantiation_values(
+            self.infcx,
+            &original_values,
+            &response,
+        );
 
         let Response { var_values, external_constraints, certainty } =
-            response.substitute(self.tcx(), &substitution);
+            response.instantiate(self.tcx(), &instantiation);
 
         let nested_goals =
             Self::unify_query_var_values(self.infcx, param_env, &original_values, var_values)?;
@@ -209,10 +212,10 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
         Ok((certainty, nested_goals))
     }
 
-    /// This returns the substitutions to instantiate the bound variables of
+    /// This returns the canoncial variable values to instantiate the bound variables of
     /// the canonical response. This depends on the `original_values` for the
     /// bound variables.
-    fn compute_query_response_substitution<T: ResponseT<'tcx>>(
+    fn compute_query_response_instantiation_values<T: ResponseT<'tcx>>(
         infcx: &InferCtxt<'tcx>,
         original_values: &[ty::GenericArg<'tcx>],
         response: &Canonical<'tcx, T>,
@@ -369,10 +372,10 @@ impl<'tcx> inspect::ProofTreeBuilder<'tcx> {
         original_values: &[ty::GenericArg<'tcx>],
         state: inspect::CanonicalState<'tcx, T>,
     ) -> Result<(Vec<Goal<'tcx, ty::Predicate<'tcx>>>, T), NoSolution> {
-        let substitution =
-            EvalCtxt::compute_query_response_substitution(infcx, original_values, &state);
+        let instantiation =
+            EvalCtxt::compute_query_response_instantiation_values(infcx, original_values, &state);
 
-        let inspect::State { var_values, data } = state.substitute(infcx.tcx, &substitution);
+        let inspect::State { var_values, data } = state.instantiate(infcx.tcx, &instantiation);
 
         let nested_goals =
             EvalCtxt::unify_query_var_values(infcx, param_env, original_values, var_values)?;

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

@@ -312,8 +312,8 @@ fn rematch_unsize<'tcx>(
             let a_tail_ty = tail_field_ty.instantiate(tcx, a_args);
             let b_tail_ty = tail_field_ty.instantiate(tcx, b_args);
 
-            // Substitute just the unsizing params from B into A. The type after
-            // this substitution must be equal to B. This is so we don't unsize
+            // Instantiate just the unsizing params from B into A. The type after
+            // this instantiation must be equal to B. This is so we don't unsize
             // unrelated type parameters.
             let new_a_args = tcx.mk_args_from_iter(
                 a_args
@@ -349,7 +349,7 @@ fn rematch_unsize<'tcx>(
             let (a_last_ty, a_rest_tys) = a_tys.split_last().unwrap();
             let b_last_ty = b_tys.last().unwrap();
 
-            // Substitute just the tail field of B., and require that they're equal.
+            // Instantiate just the tail field of B., and require that they're equal.
             let unsized_a_ty =
                 Ty::new_tup_from_iter(tcx, a_rest_tys.iter().chain([b_last_ty]).copied());
             nested.extend(

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

@@ -1,7 +1,7 @@
 //! Computes a normalizes-to (projection) goal for inherent associated types,
 //! `#![feature(inherent_associated_type)]`. Since astconv already determines
 //! which impl the IAT is being projected from, we just:
-//! 1. instantiate substs,
+//! 1. instantiate generic parameters,
 //! 2. equate the self type, and
 //! 3. instantiate and register where clauses.
 use rustc_middle::traits::solve::{Certainty, Goal, GoalSource, QueryResult};
@@ -19,21 +19,21 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
         let expected = goal.predicate.term.ty().expect("inherent consts are treated separately");
 
         let impl_def_id = tcx.parent(inherent.def_id);
-        let impl_substs = self.fresh_args_for_item(impl_def_id);
+        let impl_args = self.fresh_args_for_item(impl_def_id);
 
         // Equate impl header and add impl where clauses
         self.eq(
             goal.param_env,
             inherent.self_ty(),
-            tcx.type_of(impl_def_id).instantiate(tcx, impl_substs),
+            tcx.type_of(impl_def_id).instantiate(tcx, impl_args),
         )?;
 
         // Equate IAT with the RHS of the project goal
-        let inherent_substs = inherent.rebase_inherent_args_onto_impl(impl_substs, tcx);
+        let inherent_args = inherent.rebase_inherent_args_onto_impl(impl_args, tcx);
         self.eq(
             goal.param_env,
             expected,
-            tcx.type_of(inherent.def_id).instantiate(tcx, inherent_substs),
+            tcx.type_of(inherent.def_id).instantiate(tcx, inherent_args),
         )
         .expect("expected goal term to be fully unconstrained");
 
@@ -46,7 +46,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
         self.add_goals(
             GoalSource::Misc,
             tcx.predicates_of(inherent.def_id)
-                .instantiate(tcx, inherent_substs)
+                .instantiate(tcx, inherent_args)
                 .into_iter()
                 .map(|(pred, _)| goal.with(tcx, pred)),
         );

compiler/rustc_trait_selection/src/solve/trait_goals.rs

@@ -877,8 +877,8 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
         let a_tail_ty = tail_field_ty.instantiate(tcx, a_args);
         let b_tail_ty = tail_field_ty.instantiate(tcx, b_args);
 
-        // Substitute just the unsizing params from B into A. The type after
-        // this substitution must be equal to B. This is so we don't unsize
+        // Instantiate just the unsizing params from B into A. The type after
+        // this instantiation must be equal to B. This is so we don't unsize
         // unrelated type parameters.
         let new_a_args = tcx.mk_args_from_iter(
             a_args
@@ -927,7 +927,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
         let (&a_last_ty, a_rest_tys) = a_tys.split_last().unwrap();
         let &b_last_ty = b_tys.last().unwrap();
 
-        // Substitute just the tail field of B., and require that they're equal.
+        // Instantiate just the tail field of B., and require that they're equal.
         let unsized_a_ty =
             Ty::new_tup_from_iter(tcx, a_rest_tys.iter().copied().chain([b_last_ty]));
         self.eq(goal.param_env, unsized_a_ty, b_ty)?;