Allow IDE layer to "see" fake builtin derive impls

It sees them as regular impls; the details are abstracted. It's beautiful for the IDE layer, and less beautiful for `hir`, so this is a big change.

Some small differences still exist:

 - We show builtin derives impl (to the IDE layer) as if they have had no generic parameters. It is possible to show the parameters, but that means also having to handle fake impls in `TypeParam` etc., and the benefit is questionable.
 - Getting the fn *def* type of a method of a builtin derive impl is not supported, as there is no real `FunctionId`, therefore no `CallableDefId`. The trait method is returned instead. Note: getting the fn *ptr* type of the method is supported well.
 - Builtin derive impls and their methods do not fully support `HasSource`, because, well, they have no source (at least, not in the form of `ast::Impl` and `ast::Fn`). To support them, we use the derive's `TextRange` where possible, and the trait method's source when not.

 It's important to note that the def map still records the `MacroCallId`. I have doubts over this, as this means it's very easy to create the queries we don't want to create, but it does make things more convenient. In particular, a nicety of this setup is that even "Expand macro recursively" works (it creates the macro input/output query, but given that they will only be created when the user invokes the command, that does not seem to be a problem).

Author: ChayimFriedman2

crates/hir-def/src/builtin_derive.rs

@@ -3,40 +3,102 @@
 //! To save time and memory, builtin derives are not really expanded. Instead, we record them
 //! and create their impls based on lowered data, see crates/hir-ty/src/builtin_derive.rs.
 
-use hir_expand::builtin::BuiltinDeriveExpander;
+use hir_expand::{InFile, builtin::BuiltinDeriveExpander, name::Name};
+use intern::{Symbol, sym};
+use tt::TextRange;
+
+use crate::{
+    AdtId, BuiltinDeriveImplId, BuiltinDeriveImplLoc, FunctionId, HasModule, db::DefDatabase,
+};
 
 macro_rules! declare_enum {
-    ( $( $trait:ident ),* $(,)? ) => {
+    ( $( $trait:ident => [ $( $method:ident ),* ] ),* $(,)? ) => {
         #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
         pub enum BuiltinDeriveImplTrait {
             $( $trait, )*
         }
 
+        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+        #[allow(non_camel_case_types)]
+        pub enum BuiltinDeriveImplMethod {
+            $( $( $method, )* )*
+        }
+
         impl BuiltinDeriveImplTrait {
+            #[inline]
+            pub fn name(self) -> Symbol {
+                match self {
+                    $( Self::$trait => sym::$trait, )*
+                }
+            }
+
             #[inline]
             pub fn get_id(self, lang_items: &crate::lang_item::LangItems) -> Option<crate::TraitId> {
                 match self {
                     $( Self::$trait => lang_items.$trait, )*
                 }
             }
+
+            #[inline]
+            pub fn get_method(self, method_name: &Symbol) -> Option<BuiltinDeriveImplMethod> {
+                match self {
+                    $(
+                        Self::$trait => {
+                            match method_name {
+                                $( _ if *method_name == sym::$method => Some(BuiltinDeriveImplMethod::$method), )*
+                                _ => None,
+                            }
+                        }
+                    )*
+                }
+            }
+
+            #[inline]
+            pub fn all_methods(self) -> &'static [BuiltinDeriveImplMethod] {
+                match self {
+                    $( Self::$trait => &[ $(BuiltinDeriveImplMethod::$method),* ], )*
+                }
+            }
+        }
+
+        impl BuiltinDeriveImplMethod {
+            #[inline]
+            pub fn name(self) -> Symbol {
+                match self {
+                    $( $( BuiltinDeriveImplMethod::$method => sym::$method, )* )*
+                }
+            }
         }
     };
 }
 
 declare_enum!(
-    Copy,
-    Clone,
-    Default,
-    Debug,
-    Hash,
-    Ord,
-    PartialOrd,
-    Eq,
-    PartialEq,
-    CoerceUnsized,
-    DispatchFromDyn,
+    Copy => [],
+    Clone => [clone],
+    Default => [default],
+    Debug => [fmt],
+    Hash => [hash],
+    Ord => [cmp],
+    PartialOrd => [partial_cmp],
+    Eq => [],
+    PartialEq => [eq],
+    CoerceUnsized => [],
+    DispatchFromDyn => [],
 );
 
+impl BuiltinDeriveImplMethod {
+    pub fn trait_method(
+        self,
+        db: &dyn DefDatabase,
+        impl_: BuiltinDeriveImplId,
+    ) -> Option<FunctionId> {
+        let loc = impl_.loc(db);
+        let lang_items = crate::lang_item::lang_items(db, loc.krate(db));
+        let trait_ = impl_.loc(db).trait_.get_id(lang_items)?;
+        trait_.trait_items(db).method_by_name(&Name::new_symbol_root(self.name()))
+    }
+}
+
 pub(crate) fn with_derive_traits(
     derive: BuiltinDeriveExpander,
     mut f: impl FnMut(BuiltinDeriveImplTrait),
@@ -59,3 +121,25 @@ pub(crate) fn with_derive_traits(
     };
     f(trait_);
 }
+
+impl BuiltinDeriveImplLoc {
+    pub fn source(&self, db: &dyn DefDatabase) -> InFile<TextRange> {
+        let (adt_ast_id, module) = match self.adt {
+            AdtId::StructId(adt) => {
+                let adt_loc = adt.loc(db);
+                (adt_loc.id.upcast(), adt_loc.container)
+            }
+            AdtId::UnionId(adt) => {
+                let adt_loc = adt.loc(db);
+                (adt_loc.id.upcast(), adt_loc.container)
+            }
+            AdtId::EnumId(adt) => {
+                let adt_loc = adt.loc(db);
+                (adt_loc.id.upcast(), adt_loc.container)
+            }
+        };
+        let derive_range =
+            self.derive_attr_id.find_derive_range(db, module.krate, adt_ast_id, self.derive_index);
+        adt_ast_id.with_value(derive_range)
+    }
+}

crates/hir-def/src/item_scope.rs

@@ -9,7 +9,7 @@ use indexmap::map::Entry;
 use itertools::Itertools;
 use la_arena::Idx;
 use rustc_hash::{FxHashMap, FxHashSet};
-use smallvec::{SmallVec, smallvec};
+use smallvec::SmallVec;
 use span::Edition;
 use stdx::format_to;
 use syntax::ast;
@@ -536,12 +536,13 @@ impl ItemScope {
         adt: AstId<ast::Adt>,
         attr_id: AttrId,
         attr_call_id: MacroCallId,
-        len: usize,
+        mut derive_call_ids: SmallVec<[Option<MacroCallId>; 4]>,
     ) {
+        derive_call_ids.shrink_to_fit();
         self.derive_macros.entry(adt).or_default().push(DeriveMacroInvocation {
             attr_id,
             attr_call_id,
-            derive_call_ids: smallvec![None; len],
+            derive_call_ids,
         });
     }
 

crates/hir-def/src/lib.rs

@@ -64,6 +64,7 @@ use base_db::{Crate, impl_intern_key};
 use hir_expand::{
     AstId, ExpandResult, ExpandTo, HirFileId, InFile, MacroCallId, MacroCallKind, MacroCallStyles,
     MacroDefId, MacroDefKind,
+    attrs::AttrId,
     builtin::{BuiltinAttrExpander, BuiltinDeriveExpander, BuiltinFnLikeExpander, EagerExpander},
     db::ExpandDatabase,
     eager::expand_eager_macro_input,
@@ -338,6 +339,8 @@ impl ImplId {
 pub struct BuiltinDeriveImplLoc {
     pub adt: AdtId,
     pub trait_: BuiltinDeriveImplTrait,
+    pub derive_attr_id: AttrId,
+    pub derive_index: u32,
 }
 
 #[salsa::interned(debug, no_lifetime)]
@@ -768,6 +771,18 @@ impl_from!(
     for ModuleDefId
 );
 
+impl From<DefWithBodyId> for ModuleDefId {
+    #[inline]
+    fn from(value: DefWithBodyId) -> Self {
+        match value {
+            DefWithBodyId::FunctionId(id) => id.into(),
+            DefWithBodyId::StaticId(id) => id.into(),
+            DefWithBodyId::ConstId(id) => id.into(),
+            DefWithBodyId::VariantId(id) => id.into(),
+        }
+    }
+}
+
 /// A constant, which might appears as a const item, an anonymous const block in expressions
 /// or patterns, or as a constant in types with const generics.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, salsa_macros::Supertype)]