Remove pointless canonicalizing in method_resolution

Author: Veykril

crates/hir-ty/src/method_resolution.rs

@@ -5,7 +5,7 @@
 use std::ops::ControlFlow;
 
 use base_db::{CrateId, Edition};
-use chalk_ir::{cast::Cast, Mutability, TyKind, UniverseIndex, WhereClause};
+use chalk_ir::{cast::Cast, Mutability, TyKind, TyVariableKind, UniverseIndex, WhereClause};
 use hir_def::{
     data::{adt::StructFlags, ImplData},
     nameres::DefMap,
@@ -1000,14 +1000,14 @@ pub fn iterate_method_candidates_dyn(
 #[tracing::instrument(skip_all, fields(name = ?name))]
 fn iterate_method_candidates_with_autoref(
     table: &mut InferenceTable<'_>,
-    receiver_ty: Canonical<Ty>,
+    receiver_ty: Ty,
     first_adjustment: ReceiverAdjustments,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
     mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
 ) -> ControlFlow<()> {
-    if receiver_ty.value.is_general_var(Interner, &receiver_ty.binders) {
+    if let TyKind::InferenceVar(_, TyVariableKind::General) = receiver_ty.kind(Interner) {
         // don't try to resolve methods on unknown types
         return ControlFlow::Continue(());
     }
@@ -1025,43 +1025,36 @@ fn iterate_method_candidates_with_autoref(
     };
 
     let mut maybe_reborrowed = first_adjustment.clone();
-    if let Some((_, _, m)) = receiver_ty.value.as_reference() {
+    if let Some((_, _, m)) = receiver_ty.as_reference() {
         // Prefer reborrow of references to move
         maybe_reborrowed.autoref = Some(m);
         maybe_reborrowed.autoderefs += 1;
     }
 
     iterate_method_candidates_by_receiver(receiver_ty.clone(), maybe_reborrowed)?;
 
-    let refed = Canonical {
-        value: TyKind::Ref(Mutability::Not, static_lifetime(), receiver_ty.value.clone())
-            .intern(Interner),
-        binders: receiver_ty.binders.clone(),
-    };
+    let refed =
+        TyKind::Ref(Mutability::Not, static_lifetime(), receiver_ty.clone()).intern(Interner);
 
     iterate_method_candidates_by_receiver(refed, first_adjustment.with_autoref(Mutability::Not))?;
 
-    let ref_muted = Canonical {
-        value: TyKind::Ref(Mutability::Mut, static_lifetime(), receiver_ty.value.clone())
-            .intern(Interner),
-        binders: receiver_ty.binders.clone(),
-    };
+    let ref_muted =
+        TyKind::Ref(Mutability::Mut, static_lifetime(), receiver_ty.clone()).intern(Interner);
 
     iterate_method_candidates_by_receiver(ref_muted, first_adjustment.with_autoref(Mutability::Mut))
 }
 
 #[tracing::instrument(skip_all, fields(name = ?name))]
 fn iterate_method_candidates_by_receiver(
     table: &mut InferenceTable<'_>,
-    receiver_ty: Canonical<Ty>,
+    receiver_ty: Ty,
     receiver_adjustments: ReceiverAdjustments,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
     mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
 ) -> ControlFlow<()> {
     table.run_in_snapshot(|table| {
-        let receiver_ty = table.instantiate_canonical(receiver_ty.clone());
         // We're looking for methods with *receiver* type receiver_ty. These could
         // be found in any of the derefs of receiver_ty, so we have to go through
         // that, including raw derefs.
@@ -1358,7 +1351,8 @@ pub(crate) fn resolve_indexing_op(
     let ty = table.instantiate_canonical(ty);
     let deref_chain = autoderef_method_receiver(&mut table, ty);
     for (ty, adj) in deref_chain {
-        let goal = generic_implements_goal(db, &table.trait_env, index_trait, &ty);
+        let canonical = table.canonicalize(ty);
+        let goal = generic_implements_goal(db, &table.trait_env, index_trait, &canonical);
         if db
             .trait_solve(table.trait_env.krate, table.trait_env.block, goal.cast(Interner))
             .is_some()
@@ -1638,24 +1632,21 @@ fn generic_implements_goal(
 fn autoderef_method_receiver(
     table: &mut InferenceTable<'_>,
     ty: Ty,
-) -> Vec<(Canonical<Ty>, ReceiverAdjustments)> {
+) -> Vec<(Ty, ReceiverAdjustments)> {
     let mut deref_chain: Vec<_> = Vec::new();
-    let mut autoderef = autoderef::Autoderef::new(table, ty, false);
-    while let Some((ty, derefs)) = autoderef.next() {
+    let autoderef = autoderef::Autoderef::new(table, ty, false);
+    for (ty, derefs) in autoderef {
         deref_chain.push((
-            autoderef.table.canonicalize(ty),
+            ty,
             ReceiverAdjustments { autoref: None, autoderefs: derefs, unsize_array: false },
         ));
     }
     // As a last step, we can do array unsizing (that's the only unsizing that rustc does for method receivers!)
-    if let Some((TyKind::Array(parameters, _), binders, adj)) =
-        deref_chain.last().map(|(ty, adj)| (ty.value.kind(Interner), ty.binders.clone(), adj))
+    if let Some((TyKind::Array(parameters, _), adj)) =
+        deref_chain.last().map(|(ty, adj)| (ty.kind(Interner), adj))
     {
         let unsized_ty = TyKind::Slice(parameters.clone()).intern(Interner);
-        deref_chain.push((
-            Canonical { value: unsized_ty, binders },
-            ReceiverAdjustments { unsize_array: true, ..adj.clone() },
-        ));
+        deref_chain.push((unsized_ty, ReceiverAdjustments { unsize_array: true, ..adj.clone() }));
     }
     deref_chain
 }