avoid some unnecessary interning

Author: lcnr

compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs

@@ -261,34 +261,33 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
     /// variable in the future by changing the way we detect global where-bounds.
     pub(super) fn canonicalize_input<P: TypeFoldable<I>>(
         delegate: &'a D,
-        input: QueryInput<I, P>,
+        Goal { param_env, predicate }: Goal<I, P>,
+        predefined_opaques_in_body: Vec<(ty::OpaqueTypeKey<I>, I::Ty)>,
+        pseudo_rigid_due_to_opaques: Vec<(I::Ty, ty::PseudoRigidDueToOpaquesBound<I>)>,
     ) -> (ThinVec<I::GenericArg>, ty::Canonical<I, QueryInput<I, P>>) {
         // First canonicalize the `param_env` while keeping `'static`. This produces a
         // canonicalizer that can canonicalize the rest of the input without keeping `'static`.
-        let (param_env, mut rest_canonicalizer) =
-            Self::canonicalize_param_env(delegate, input.goal.param_env);
+        let (param_env, mut rest_canonicalizer) = Self::canonicalize_param_env(delegate, param_env);
 
-        let predicate = input.goal.predicate;
         let predicate = predicate.fold_with(&mut rest_canonicalizer);
         let goal = Goal { param_env, predicate };
 
-        let predefined_opaques_in_body = input.predefined_opaques_in_body;
         let predefined_opaques_in_body =
             if predefined_opaques_in_body.has_type_flags(NEEDS_CANONICAL) {
                 predefined_opaques_in_body.fold_with(&mut rest_canonicalizer)
             } else {
                 predefined_opaques_in_body
             };
+        let predefined_opaques_in_body =
+            delegate.cx().mk_predefined_opaques_in_body(&predefined_opaques_in_body);
 
         let pseudo_rigid_due_to_opaques = rest_canonicalizer
-            .filter_and_canonicalize_pseudo_rigids_due_to_opaques(
-                input.pseudo_rigid_due_to_opaques.to_vec(),
-            );
+            .filter_and_canonicalize_pseudo_rigids_due_to_opaques(pseudo_rigid_due_to_opaques);
 
         let value = QueryInput { goal, predefined_opaques_in_body, pseudo_rigid_due_to_opaques };
-
         debug_assert!(!value.has_infer(), "unexpected infer in {value:?}");
         debug_assert!(!value.has_placeholders(), "unexpected placeholders in {value:?}");
+    
         let (max_universe, variables, var_kinds) = rest_canonicalizer.finalize();
         (variables, Canonical { max_universe, var_kinds, value })
     }

compiler/rustc_next_trait_solver/src/canonical/mod.rs

@@ -27,8 +27,7 @@ use tracing::instrument;
 use crate::delegate::SolverDelegate;
 use crate::solve::{
     CanonicalResponse, Certainty, ExternalConstraintsData, ExternalRegionConstraints, Goal,
-    NestedNormalizationGoals, QueryInput, RawExternalConstraintsData, Response,
-    VisibleForLeakCheck, inspect,
+    NestedNormalizationGoals, RawExternalConstraintsData, Response, VisibleForLeakCheck, inspect,
 };
 
 pub mod canonicalizer;
@@ -56,8 +55,8 @@ impl<I: Interner, T> ResponseT<I> for inspect::State<I, T> {
 pub(super) fn canonicalize_goal<D, I>(
     delegate: &D,
     goal: Goal<I, I::Predicate>,
-    opaque_types: &[(ty::OpaqueTypeKey<I>, I::Ty)],
-    pseudo_rigid_due_to_opaques: &[(I::Ty, ty::PseudoRigidDueToOpaquesBound<I>)],
+    opaque_types: Vec<(ty::OpaqueTypeKey<I>, I::Ty)>,
+    pseudo_rigid_due_to_opaques: Vec<(I::Ty, ty::PseudoRigidDueToOpaquesBound<I>)>,
     typing_mode: TypingMode<I>,
 ) -> (ThinVec<I::GenericArg>, I::CanonicalInput)
 where
@@ -66,13 +65,9 @@ where
 {
     let (orig_values, canonical) = Canonicalizer::canonicalize_input(
         delegate,
-        QueryInput {
-            goal,
-            predefined_opaques_in_body: delegate.cx().mk_predefined_opaques_in_body(opaque_types),
-            pseudo_rigid_due_to_opaques: delegate
-                .cx()
-                .mk_pseudo_rigid_due_to_opaques(pseudo_rigid_due_to_opaques),
-        },
+        goal,
+        opaque_types,
+        pseudo_rigid_due_to_opaques,
     );
 
     let query_input = delegate.cx().mk_canonical_input(ty::CanonicalQueryInput {

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

@@ -844,8 +844,8 @@ where
                 let (orig_values, canonical_goal) = canonicalize_goal(
                     self.delegate,
                     goal,
-                    &[],
-                    &[],
+                    Vec::new(),
+                    Vec::new(),
                     TypingMode::ErasedNotCoherence(MayBeErased),
                 );
 
@@ -885,8 +885,8 @@ where
             let (orig_values, canonical_goal) = canonicalize_goal(
                 self.delegate,
                 goal,
-                &opaque_types,
-                &pseudo_rigid_due_to_opaques,
+                opaque_types,
+                pseudo_rigid_due_to_opaques,
                 typing_mode,
             );
 
@@ -2132,8 +2132,8 @@ pub(super) fn evaluate_root_goal_for_proof_tree<D: SolverDelegate<Interner = I>,
     let (orig_values, canonical_goal) = canonicalize_goal(
         delegate,
         goal,
-        &opaque_types,
-        &pseudo_rigid_due_to_opaques,
+        opaque_types,
+        pseudo_rigid_due_to_opaques,
         typing_mode.into(),
     );