Make builtin derives cheaper, by not really expanding them, instead store them unexpanded

Author: ChayimFriedman2

crates/hir-def/src/attrs.rs

@@ -188,6 +188,7 @@ fn match_attr_flags(attr_flags: &mut AttrFlags, attr: Meta) -> ControlFlow<Infal
                     "deprecated" => attr_flags.insert(AttrFlags::IS_DEPRECATED),
                     "macro_export" => attr_flags.insert(AttrFlags::IS_MACRO_EXPORT),
                     "no_mangle" => attr_flags.insert(AttrFlags::NO_MANGLE),
+                    "pointee" => attr_flags.insert(AttrFlags::IS_POINTEE),
                     "non_exhaustive" => attr_flags.insert(AttrFlags::NON_EXHAUSTIVE),
                     "ignore" => attr_flags.insert(AttrFlags::IS_IGNORE),
                     "bench" => attr_flags.insert(AttrFlags::IS_BENCH),
@@ -289,6 +290,7 @@ bitflags::bitflags! {
         const RUSTC_PAREN_SUGAR = 1 << 42;
         const RUSTC_COINDUCTIVE = 1 << 43;
         const RUSTC_FORCE_INLINE = 1 << 44;
+        const IS_POINTEE = 1 << 45;
     }
 }
 

crates/hir-def/src/builtin_derive.rs

@@ -0,0 +1,61 @@
+//! Definition of builtin derive impls.
+//!
+//! 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;
+
+macro_rules! declare_enum {
+    ( $( $trait:ident ),* $(,)? ) => {
+        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+        pub enum BuiltinDeriveImplTrait {
+            $( $trait, )*
+        }
+
+        impl BuiltinDeriveImplTrait {
+            #[inline]
+            pub fn get_id(self, lang_items: &crate::lang_item::LangItems) -> Option<crate::TraitId> {
+                match self {
+                    $( Self::$trait => lang_items.$trait, )*
+                }
+            }
+        }
+    };
+}
+
+declare_enum!(
+    Copy,
+    Clone,
+    Default,
+    Debug,
+    Hash,
+    Ord,
+    PartialOrd,
+    Eq,
+    PartialEq,
+    CoerceUnsized,
+    DispatchFromDyn,
+);
+
+pub(crate) fn with_derive_traits(
+    derive: BuiltinDeriveExpander,
+    mut f: impl FnMut(BuiltinDeriveImplTrait),
+) {
+    let trait_ = match derive {
+        BuiltinDeriveExpander::Copy => BuiltinDeriveImplTrait::Copy,
+        BuiltinDeriveExpander::Clone => BuiltinDeriveImplTrait::Clone,
+        BuiltinDeriveExpander::Default => BuiltinDeriveImplTrait::Default,
+        BuiltinDeriveExpander::Debug => BuiltinDeriveImplTrait::Debug,
+        BuiltinDeriveExpander::Hash => BuiltinDeriveImplTrait::Hash,
+        BuiltinDeriveExpander::Ord => BuiltinDeriveImplTrait::Ord,
+        BuiltinDeriveExpander::PartialOrd => BuiltinDeriveImplTrait::PartialOrd,
+        BuiltinDeriveExpander::Eq => BuiltinDeriveImplTrait::Eq,
+        BuiltinDeriveExpander::PartialEq => BuiltinDeriveImplTrait::PartialEq,
+        BuiltinDeriveExpander::CoercePointee => {
+            f(BuiltinDeriveImplTrait::CoerceUnsized);
+            f(BuiltinDeriveImplTrait::DispatchFromDyn);
+            return;
+        }
+    };
+    f(trait_);
+}

crates/hir-def/src/item_scope.rs

@@ -16,8 +16,8 @@ use syntax::ast;
 use thin_vec::ThinVec;
 
 use crate::{
-    AdtId, BuiltinType, ConstId, ExternBlockId, ExternCrateId, FxIndexMap, HasModule, ImplId,
-    Lookup, MacroCallStyles, MacroId, ModuleDefId, ModuleId, TraitId, UseId,
+    AdtId, BuiltinDeriveImplId, BuiltinType, ConstId, ExternBlockId, ExternCrateId, FxIndexMap,
+    HasModule, ImplId, Lookup, MacroCallStyles, MacroId, ModuleDefId, ModuleId, TraitId, UseId,
     db::DefDatabase,
     per_ns::{Item, MacrosItem, PerNs, TypesItem, ValuesItem},
     visibility::Visibility,
@@ -159,6 +159,7 @@ pub struct ItemScope {
     declarations: ThinVec<ModuleDefId>,
 
     impls: ThinVec<ImplId>,
+    builtin_derive_impls: ThinVec<BuiltinDeriveImplId>,
     extern_blocks: ThinVec<ExternBlockId>,
     unnamed_consts: ThinVec<ConstId>,
     /// Traits imported via `use Trait as _;`.
@@ -329,6 +330,10 @@ impl ItemScope {
         self.impls.iter().copied()
     }
 
+    pub fn builtin_derive_impls(&self) -> impl ExactSizeIterator<Item = BuiltinDeriveImplId> + '_ {
+        self.builtin_derive_impls.iter().copied()
+    }
+
     pub fn all_macro_calls(&self) -> impl Iterator<Item = MacroCallId> + '_ {
         self.macro_invocations.values().copied().chain(self.attr_macros.values().copied()).chain(
             self.derive_macros.values().flat_map(|it| {
@@ -471,6 +476,10 @@ impl ItemScope {
         self.impls.push(imp);
     }
 
+    pub(crate) fn define_builtin_derive_impl(&mut self, imp: BuiltinDeriveImplId) {
+        self.builtin_derive_impls.push(imp);
+    }
+
     pub(crate) fn define_extern_block(&mut self, extern_block: ExternBlockId) {
         self.extern_blocks.push(extern_block);
     }
@@ -811,6 +820,7 @@ impl ItemScope {
             unresolved,
             declarations,
             impls,
+            builtin_derive_impls,
             unnamed_consts,
             unnamed_trait_imports,
             legacy_macros,
@@ -834,6 +844,7 @@ impl ItemScope {
         unresolved.shrink_to_fit();
         declarations.shrink_to_fit();
         impls.shrink_to_fit();
+        builtin_derive_impls.shrink_to_fit();
         unnamed_consts.shrink_to_fit();
         unnamed_trait_imports.shrink_to_fit();
         legacy_macros.shrink_to_fit();

crates/hir-def/src/lang_item.rs

@@ -2,6 +2,7 @@
 //!
 //! This attribute to tell the compiler about semi built-in std library
 //! features, such as Fn family of traits.
+use hir_expand::name::Name;
 use intern::{Symbol, sym};
 use stdx::impl_from;
 
@@ -10,7 +11,7 @@ use crate::{
     StaticId, StructId, TraitId, TypeAliasId, UnionId,
     attrs::AttrFlags,
     db::DefDatabase,
-    nameres::{assoc::TraitItems, crate_def_map, crate_local_def_map},
+    nameres::{DefMap, assoc::TraitItems, crate_def_map, crate_local_def_map},
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -93,6 +94,10 @@ pub fn crate_lang_items(db: &dyn DefDatabase, krate: Crate) -> Option<Box<LangIt
         }
     }
 
+    if matches!(krate.data(db).origin, base_db::CrateOrigin::Lang(base_db::LangCrateOrigin::Core)) {
+        lang_items.fill_non_lang_core_traits(db, crate_def_map);
+    }
+
     if lang_items.is_empty() { None } else { Some(Box::new(lang_items)) }
 }
 
@@ -135,6 +140,31 @@ impl LangItems {
     }
 }
 
+fn resolve_core_trait(
+    db: &dyn DefDatabase,
+    core_def_map: &DefMap,
+    modules: &[Symbol],
+    name: Symbol,
+) -> Option<TraitId> {
+    let mut current = &core_def_map[core_def_map.root];
+    for module in modules {
+        let Some((ModuleDefId::ModuleId(cur), _)) =
+            current.scope.type_(&Name::new_symbol_root(module.clone()))
+        else {
+            return None;
+        };
+        if cur.krate(db) != core_def_map.krate() || cur.block(db) != core_def_map.block_id() {
+            return None;
+        }
+        current = &core_def_map[cur];
+    }
+    let Some((ModuleDefId::TraitId(trait_), _)) = current.scope.type_(&Name::new_symbol_root(name))
+    else {
+        return None;
+    };
+    Some(trait_)
+}
+
 #[salsa::tracked(returns(as_deref))]
 pub(crate) fn crate_notable_traits(db: &dyn DefDatabase, krate: Crate) -> Option<Box<[TraitId]>> {
     let mut traits = Vec::new();
@@ -164,6 +194,10 @@ macro_rules! language_item_table {
     (
         $LangItems:ident =>
         $( $(#[$attr:meta])* $lang_item:ident, $module:ident :: $name:ident, $method:ident, $target:ident, $generics:expr; )*
+
+        @non_lang_core_traits:
+
+        $( core::$($non_lang_module:ident)::*, $non_lang_trait:ident; )*
     ) => {
         #[allow(non_snake_case)] // FIXME: Should we remove this?
         #[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
@@ -172,6 +206,9 @@ macro_rules! language_item_table {
                 $(#[$attr])*
                 pub $lang_item: Option<$target>,
             )*
+            $(
+                pub $non_lang_trait: Option<TraitId>,
+            )*
         }
 
         impl LangItems {
@@ -182,6 +219,7 @@ macro_rules! language_item_table {
             /// Merges `self` with `other`, with preference to `self` items.
             fn merge_prefer_self(&mut self, other: &Self) {
                 $( self.$lang_item = self.$lang_item.or(other.$lang_item); )*
+                $( self.$non_lang_trait = self.$non_lang_trait.or(other.$non_lang_trait); )*
             }
 
             fn assign_lang_item(&mut self, name: Symbol, target: LangItemTarget) {
@@ -196,6 +234,10 @@ macro_rules! language_item_table {
                     _ => {}
                 }
             }
+
+            fn fill_non_lang_core_traits(&mut self, db: &dyn DefDatabase, core_def_map: &DefMap) {
+                $( self.$non_lang_trait = resolve_core_trait(db, core_def_map, &[ $(sym::$non_lang_module),* ], sym::$non_lang_trait); )*
+            }
         }
 
         #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -431,4 +473,11 @@ language_item_table! { LangItems =>
     String,                  sym::String,              string,                     StructId,               GenericRequirement::None;
     CStr,                    sym::CStr,                c_str,                      StructId,               GenericRequirement::None;
     Ordering,                sym::Ordering,            ordering,                   EnumId,                 GenericRequirement::None;
+
+    @non_lang_core_traits:
+    core::default, Default;
+    core::fmt, Debug;
+    core::hash, Hash;
+    core::cmp, Ord;
+    core::cmp, Eq;
 }

crates/hir-def/src/lib.rs

@@ -30,6 +30,7 @@ pub mod dyn_map;
 
 pub mod item_tree;
 
+pub mod builtin_derive;
 pub mod lang_item;
 
 pub mod hir;
@@ -80,6 +81,7 @@ pub use hir_expand::{Intern, Lookup, tt};
 
 use crate::{
     attrs::AttrFlags,
+    builtin_derive::BuiltinDeriveImplTrait,
     builtin_type::BuiltinType,
     db::DefDatabase,
     expr_store::ExpressionStoreSourceMap,
@@ -331,6 +333,19 @@ impl ImplId {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct BuiltinDeriveImplLoc {
+    pub adt: AdtId,
+    pub trait_: BuiltinDeriveImplTrait,
+}
+
+#[salsa::interned(debug, no_lifetime)]
+#[derive(PartialOrd, Ord)]
+pub struct BuiltinDeriveImplId {
+    #[returns(ref)]
+    pub loc: BuiltinDeriveImplLoc,
+}
+
 type UseLoc = ItemLoc<ast::Use>;
 impl_intern!(UseId, UseLoc, intern_use, lookup_intern_use);
 
@@ -1009,6 +1024,20 @@ fn module_for_assoc_item_loc<'db>(
     id.lookup(db).container.module(db)
 }
 
+impl HasModule for BuiltinDeriveImplLoc {
+    #[inline]
+    fn module(&self, db: &dyn DefDatabase) -> ModuleId {
+        self.adt.module(db)
+    }
+}
+
+impl HasModule for BuiltinDeriveImplId {
+    #[inline]
+    fn module(&self, db: &dyn DefDatabase) -> ModuleId {
+        self.loc(db).module(db)
+    }
+}
+
 impl HasModule for FunctionId {
     #[inline]
     fn module(&self, db: &dyn DefDatabase) -> ModuleId {