Auto merge of #17618 - Veykril:rustc_skip_during_method_dispatch, r=Veykril

Support rustc_skip_during_method_dispatch

Fixes rust-lang/rust-analyzer#17256

Author: bors

src/tools/rust-analyzer/crates/hir-def/src/data.rs

@@ -223,6 +223,7 @@ pub struct TraitData {
     pub is_unsafe: bool,
     pub rustc_has_incoherent_inherent_impls: bool,
     pub skip_array_during_method_dispatch: bool,
+    pub skip_boxed_slice_during_method_dispatch: bool,
     pub fundamental: bool,
     pub visibility: RawVisibility,
     /// Whether the trait has `#[rust_skip_array_during_method_dispatch]`. `hir_ty` will ignore
@@ -250,8 +251,17 @@ impl TraitData {
         let is_unsafe = tr_def.is_unsafe;
         let visibility = item_tree[tr_def.visibility].clone();
         let attrs = item_tree.attrs(db, module_id.krate(), ModItem::from(tree_id.value).into());
-        let skip_array_during_method_dispatch =
+        let mut skip_array_during_method_dispatch =
             attrs.by_key(&sym::rustc_skip_array_during_method_dispatch).exists();
+        let mut skip_boxed_slice_during_method_dispatch = false;
+        for tt in attrs.by_key(&sym::rustc_skip_during_method_dispatch).tt_values() {
+            for tt in tt.token_trees.iter() {
+                if let crate::tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) = tt {
+                    skip_array_during_method_dispatch |= ident.sym == sym::array;
+                    skip_boxed_slice_during_method_dispatch |= ident.sym == sym::boxed_slice;
+                }
+            }
+        }
         let rustc_has_incoherent_inherent_impls =
             attrs.by_key(&sym::rustc_has_incoherent_inherent_impls).exists();
         let fundamental = attrs.by_key(&sym::fundamental).exists();
@@ -269,6 +279,7 @@ impl TraitData {
                 is_unsafe,
                 visibility,
                 skip_array_during_method_dispatch,
+                skip_boxed_slice_during_method_dispatch,
                 rustc_has_incoherent_inherent_impls,
                 fundamental,
             }),

src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs

@@ -5,7 +5,7 @@
 use std::ops::ControlFlow;
 
 use base_db::CrateId;
-use chalk_ir::{cast::Cast, Mutability, TyKind, UniverseIndex, WhereClause};
+use chalk_ir::{cast::Cast, UniverseIndex, WithKind};
 use hir_def::{
     data::{adt::StructFlags, ImplData},
     nameres::DefMap,
@@ -16,7 +16,6 @@ use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::{FxHashMap, FxHashSet};
 use smallvec::{smallvec, SmallVec};
-use span::Edition;
 use stdx::never;
 use triomphe::Arc;
 
@@ -25,12 +24,14 @@ use crate::{
     db::HirDatabase,
     error_lifetime, from_chalk_trait_id, from_foreign_def_id,
     infer::{unify::InferenceTable, Adjust, Adjustment, OverloadedDeref, PointerCast},
+    lang_items::is_box,
     primitive::{FloatTy, IntTy, UintTy},
     to_chalk_trait_id,
     utils::all_super_traits,
-    AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, DynTyExt, ForeignDefId, Goal, Guidance,
-    InEnvironment, Interner, Scalar, Solution, Substitution, TraitEnvironment, TraitRef,
-    TraitRefExt, Ty, TyBuilder, TyExt,
+    AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, DynTyExt, ForeignDefId, GenericArgData,
+    Goal, Guidance, InEnvironment, Interner, Mutability, Scalar, Solution, Substitution,
+    TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, VariableKind,
+    WhereClause,
 };
 
 /// This is used as a key for indexing impls.
@@ -1146,17 +1147,30 @@ fn iterate_trait_method_candidates(
     'traits: for &t in traits_in_scope {
         let data = db.trait_data(t);
 
-        // Traits annotated with `#[rustc_skip_array_during_method_dispatch]` are skipped during
+        // Traits annotated with `#[rustc_skip_during_method_dispatch]` are skipped during
         // method resolution, if the receiver is an array, and we're compiling for editions before
         // 2021.
         // This is to make `[a].into_iter()` not break code with the new `IntoIterator` impl for
         // arrays.
         if data.skip_array_during_method_dispatch
-            && matches!(self_ty.kind(Interner), chalk_ir::TyKind::Array(..))
+            && matches!(self_ty.kind(Interner), TyKind::Array(..))
         {
             // FIXME: this should really be using the edition of the method name's span, in case it
             // comes from a macro
-            if db.crate_graph()[krate].edition < Edition::Edition2021 {
+            if !db.crate_graph()[krate].edition.at_least_2021() {
+                continue;
+            }
+        }
+        if data.skip_boxed_slice_during_method_dispatch
+            && matches!(
+                self_ty.kind(Interner), TyKind::Adt(AdtId(def), subst)
+                if is_box(table.db, *def)
+                    && matches!(subst.at(Interner, 0).assert_ty_ref(Interner).kind(Interner), TyKind::Slice(..))
+            )
+        {
+            // FIXME: this should really be using the edition of the method name's span, in case it
+            // comes from a macro
+            if !db.crate_graph()[krate].edition.at_least_2024() {
                 continue;
             }
         }
@@ -1619,15 +1633,11 @@ fn generic_implements_goal(
     let kinds =
         binders.iter().cloned().chain(trait_ref.substitution.iter(Interner).skip(1).map(|it| {
             let vk = match it.data(Interner) {
-                chalk_ir::GenericArgData::Ty(_) => {
-                    chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General)
-                }
-                chalk_ir::GenericArgData::Lifetime(_) => chalk_ir::VariableKind::Lifetime,
-                chalk_ir::GenericArgData::Const(c) => {
-                    chalk_ir::VariableKind::Const(c.data(Interner).ty.clone())
-                }
+                GenericArgData::Ty(_) => VariableKind::Ty(chalk_ir::TyVariableKind::General),
+                GenericArgData::Lifetime(_) => VariableKind::Lifetime,
+                GenericArgData::Const(c) => VariableKind::Const(c.data(Interner).ty.clone()),
             };
-            chalk_ir::WithKind::new(vk, UniverseIndex::ROOT)
+            WithKind::new(vk, UniverseIndex::ROOT)
         }));
     let binders = CanonicalVarKinds::from_iter(Interner, kinds);
 

src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs

@@ -1640,6 +1640,55 @@ impl<'a, T> IntoIterator for &'a [T] {
     );
 }
 
+#[test]
+fn skip_during_method_dispatch() {
+    check_types(
+        r#"
+//- /main2018.rs crate:main2018 deps:core edition:2018
+use core::IntoIterator;
+
+fn f() {
+    let v = [4].into_iter();
+    v;
+  //^ &'? i32
+
+    let a = [0, 1].into_iter();
+    a;
+  //^ &'? i32
+}
+
+//- /main2021.rs crate:main2021 deps:core edition:2021
+use core::IntoIterator;
+
+fn f() {
+    let v = [4].into_iter();
+    v;
+  //^ i32
+
+    let a = [0, 1].into_iter();
+    a;
+  //^ &'? i32
+}
+
+//- /core.rs crate:core
+#[rustc_skip_during_method_dispatch(array, boxed_slice)]
+pub trait IntoIterator {
+    type Out;
+    fn into_iter(self) -> Self::Out;
+}
+
+impl<T> IntoIterator for [T; 1] {
+    type Out = T;
+    fn into_iter(self) -> Self::Out { loop {} }
+}
+impl<'a, T> IntoIterator for &'a [T] {
+    type Out = &'a T;
+    fn into_iter(self) -> Self::Out { loop {} }
+}
+    "#,
+    );
+}
+
 #[test]
 fn sized_blanket_impl() {
     check_infer(

src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs

@@ -400,6 +400,7 @@ define_symbols! {
     rustc_reservation_impl,
     rustc_safe_intrinsic,
     rustc_skip_array_during_method_dispatch,
+    rustc_skip_during_method_dispatch,
     semitransparent,
     shl_assign,
     shl,
@@ -455,4 +456,6 @@ define_symbols! {
     vectorcall,
     wasm,
     win64,
+    array,
+    boxed_slice,
 }

src/tools/rust-analyzer/crates/parser/src/edition.rs

@@ -20,6 +20,10 @@ impl Edition {
         self >= Edition::Edition2024
     }
 
+    pub fn at_least_2021(self) -> bool {
+        self >= Edition::Edition2021
+    }
+
     pub fn at_least_2018(self) -> bool {
         self >= Edition::Edition2018
     }