chore: remove any locking concerns from the module system

Author: indietyp

libs/@local/hashql/core/src/lib.rs

@@ -39,7 +39,8 @@
     sync_nonpoison,
     try_trait_v2,
     variant_count,
-    iter_collect_into
+    iter_collect_into,
+    maybe_uninit_fill
 )]
 
 extern crate alloc;

libs/@local/hashql/core/src/module/item.rs

@@ -76,6 +76,7 @@ pub struct Item<'heap> {
 }
 
 impl<'heap> Item<'heap> {
+    #[must_use]
     pub fn ancestors(
         &self,
         registry: &ModuleRegistry<'heap>,

libs/@local/hashql/core/src/module/mod.rs

@@ -25,7 +25,6 @@ use crate::{
     collections::{FastHashMap, fast_hash_map_in},
     heap::{BumpAllocator as _, Heap},
     id::{HasId, Id as _, IdSlice, IdVec, bit_vec::DenseBitSet, newtype},
-    intern::{Decompose, InternSet, Interned},
     symbol::Symbol,
     r#type::environment::Environment,
 };
@@ -40,17 +39,17 @@ impl ModuleId {
 }
 
 pub struct PartialModuleRegistry<'heap, S: Allocator> {
+    heap: &'heap Heap,
     modules: IdVec<ModuleId, Option<Module<'heap>>, S>,
-    items: InternSet<'heap, [Item<'heap>]>,
 
     root: FastHashMap<Symbol<'heap>, ModuleId, &'heap Heap>,
 }
 
 impl<'heap, S: Allocator> PartialModuleRegistry<'heap, S> {
     pub fn new_in(heap: &'heap Heap, scratch: S) -> Self {
         Self {
+            heap,
             modules: IdVec::new_in(scratch),
-            items: InternSet::new(heap),
             root: fast_hash_map_in(heap),
         }
     }
@@ -89,11 +88,6 @@ impl<'heap, S: Allocator> PartialModuleRegistry<'heap, S> {
         debug_assert!(value.is_none());
     }
 
-    /// Interns a slice of items into the registry.
-    pub fn intern_items(&self, items: &[Item<'heap>]) -> Interned<'heap, [Item<'heap>]> {
-        self.items.intern_slice(items)
-    }
-
     /// Register a new module in the root namespace.
     ///
     /// # Panics
@@ -363,7 +357,7 @@ pub struct Module<'heap> {
     pub parent: ModuleId,
     pub depth: NonZero<u32>,
 
-    pub items: Interned<'heap, [Item<'heap>]>,
+    pub items: &'heap [Item<'heap>],
 }
 
 impl<'heap> Module<'heap> {
@@ -388,28 +382,6 @@ impl<'heap> Module<'heap> {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub struct PartialModule<'heap> {
-    name: Symbol<'heap>,
-    parent: ModuleId,
-    depth: NonZero<u32>,
-    items: Interned<'heap, [Item<'heap>]>,
-}
-
-impl<'heap> Decompose<'heap> for Module<'heap> {
-    type Partial = PartialModule<'heap>;
-
-    fn from_parts(id: Self::Id, partial: Interned<'heap, Self::Partial>) -> Self {
-        Self {
-            id,
-            name: partial.name,
-            parent: partial.parent,
-            depth: partial.depth,
-            items: partial.items,
-        }
-    }
-}
-
 impl HasId for Module<'_> {
     type Id = ModuleId;
 

libs/@local/hashql/core/src/module/std_lib/mod.rs

@@ -6,6 +6,7 @@ use ::core::{alloc::Allocator, iter, mem, mem::MaybeUninit, num::NonZero};
 
 use super::{Module, ModuleId, PartialModuleRegistry, item::IntrinsicItem, locals::TypeDef};
 use crate::{
+    heap::BumpAllocator as _,
     id::{Id as _, bit_vec::FiniteBitSet},
     module::item::{ConstructorItem, Item, ItemKind},
     symbol::Symbol,
@@ -249,66 +250,76 @@ impl<'heap, S: Allocator> ModuleCache<'heap, S> {
         T: StandardLibraryModule<'heap>,
         S: Clone,
     {
-        let module = context.registry.provision_module();
-        let emitted = self.request::<T>(context).emitted_len;
-
-        let mut output =
-            Vec::with_capacity_in(emitted + T::Children::LENGTH, context.alloc.clone());
-
-        T::Children::names()
-            .into_iter()
-            .zip(T::Children::modules(
-                context,
-                self,
-                depth.saturating_add(1),
-                module,
-            ))
-            .map(|(name, child)| Item {
-                module,
-                name,
-                kind: ItemKind::Module(child),
-            })
-            .collect_into(&mut output);
+        let id = context.registry.provision_module();
 
         let def = self.request::<T>(context);
 
+        let heap = context.registry.heap;
+        let output = heap.allocate_slice_uninit(def.emitted_len + T::Children::LENGTH);
+
+        let mut cursor = 0;
         for &ModuleEntry { name, def } in &def.entries {
             match def {
                 ItemDef::Intrinsic(intrinsic) => {
-                    output.push(Item {
-                        module,
+                    output[cursor].write(Item {
+                        module: id,
                         name,
                         kind: ItemKind::Intrinsic(intrinsic),
                     });
+                    cursor += 1;
                 }
                 ItemDef::Type(typedef) => {
-                    output.push(Item {
-                        module,
+                    output[cursor].write(Item {
+                        module: id,
                         name,
                         kind: ItemKind::Type(typedef),
                     });
+                    cursor += 1;
                 }
                 ItemDef::Newtype(typedef) => {
-                    output.push(Item {
-                        module,
+                    output[cursor].write(Item {
+                        module: id,
                         name,
                         kind: ItemKind::Constructor(ConstructorItem { r#type: typedef }),
                     });
-                    output.push(Item {
-                        module,
+                    cursor += 1;
+
+                    output[cursor].write(Item {
+                        module: id,
                         name,
                         kind: ItemKind::Type(typedef),
                     });
+                    cursor += 1;
                 }
             }
         }
 
+        let remaining = &mut output[cursor..];
+        let (_, remaining) = remaining.write_iter(
+            T::Children::names()
+                .into_iter()
+                .zip(T::Children::modules(
+                    context,
+                    self,
+                    depth.saturating_add(1),
+                    id,
+                ))
+                .map(|(name, child)| Item {
+                    module: id,
+                    name,
+                    kind: ItemKind::Module(child),
+                }),
+        );
+
+        assert!(remaining.is_empty());
+
         let module = Module {
-            id: module,
+            id,
             name: T::name(),
             parent,
             depth,
-            items: context.registry.intern_items(&output),
+            // SAFETY: assertion ensures that the output buffer is fully initialized before reading.
+            items: unsafe { output.assume_init_ref() },
         };
 
         context.registry.insert_module(module);