Implemented an experimental type checker

Cargo.toml

@@ -70,6 +70,7 @@ clap = { version = "4.6", features = ["derive"] }
 core_affinity2 = "0.15"
 dashmap = { version = "7.0.0-rc2", features = ["inline-more"] }
 delegate = "0.13"
+ena = "0.14"
 env_logger = { version = "0.11", features = ["kv"] }
 equivalent = "1.0"
 hashbrown = "0.17"

crates/aterm/src/aterm.rs

@@ -228,17 +228,19 @@ impl fmt::Debug for ATermRef<'_> {
 /// # Safety
 ///
 /// Note that terms use thread-local state for their protection mechanism, so
-/// [ATerm] is not [Send]. Terms should not be dropped after the thread that
-/// created them has exited, because the order in which thread-local destructors
-/// run is undefined and dropping a term after `THREAD_TERM_POOL` is gone panics.
-/// For this purpose one can wrap terms kept in thread-local storage in
-/// `ManuallyDrop` to simply never drop them.
+/// [ATerm] is not [Send]. Moreover, this means that terms cannot be stored in
+/// thread-local storage themselves, or at least must be destroyed before the
+/// thread exits, because the order in which thread-local destructors are called
+/// is undefined, and as such a term could be destroyed after the thread-local
+/// term pool is destroyed, leading to undefined behavior.
 ///
-/// Read-only inspection of a term after its originating thread has exited
-/// remains memory-safe: any roots still protected at thread teardown are adopted
-/// into a global orphan set (deduplicated), so their storage is not reclaimed.
+/// For this purpose one can use `ManuallyDrop` to simply never drop thread
+/// local terms, since exiting the thread will clean up the protection sets
+/// anyway.
 ///
-/// If you need to send a term across threads, use [ATermSend] instead.
+/// We do not mark term access as unsafe, since that would make their use
+/// cumbersome. An alternative would be to require `THREAD_TERM_POOL.with(|tp|
+/// ...)` around every access, but that would be very verbose.
 pub struct ATerm {
     term: ATermRef<'static>,
 

crates/aterm/src/storage/aterm_storage.rs

@@ -45,6 +45,10 @@ const INITIAL_CAPACITY: usize = 1024;
 /// The number of terms stored in every block of the fixed-size storage.
 const BLOCK_SIZE: usize = 1024;
 
+/// The largest arity stored in the fixed-size tables; larger terms go into the
+/// dynamically sized `terms` storage.
+pub(crate) const MAX_FIXED_ARITY: usize = 7;
+
 impl ATermStorage {
     /// Creates a new, empty storage.
     pub(crate) fn new() -> Self {
@@ -80,13 +84,76 @@ impl ATermStorage {
             "The number of arguments does not match the arity of the symbol"
         );
 
+        if symbol.arity() <= MAX_FIXED_ARITY {
+            return self.insert_fixed(symbol, args);
+        }
+
+        let shared_term = SharedTermLookup {
+            symbol: SymbolRef::from_symbol(symbol),
+            arguments: args,
+        };
+
+        unsafe {
+            self.terms
+                .insert_equiv_dst(&shared_term, SharedTerm::length_for(&shared_term), |ptr, key| {
+                    SharedTerm::construct(ptr, key)
+                })
+        }
+    }
+
+    /// Inserts a term whose arity is at most [MAX_FIXED_ARITY] into the corresponding fixed-size
+    /// storage, building the `SharedTermFixed<N>` key straight from the argument slice.
+    ///
+    /// Taking the arguments as a generic `T: Term` slice lets callers pass the terms they already
+    /// have (e.g. the input slice of [crate::ATerm::with_args]) without first materialising an
+    /// intermediate `ATermRef` buffer.
+    pub(crate) fn insert_fixed<'a, 'b, 'c, 'd, S, T>(
+        &self,
+        symbol: &'b S,
+        args: &[T],
+    ) -> (StablePointer<SharedTerm>, bool)
+    where
+        S: Symb<'a, 'b>,
+        T: Term<'c, 'd>,
+    {
+        debug_assert_eq!(
+            symbol.arity(),
+            args.len(),
+            "The number of arguments does not match the arity of the symbol"
+        );
+
         // SAFETY: the copied argument indices are stored inside the inserted term, and the
         // GC marks the arguments of every live term, so each argument stays in the pool at
         // least as long as the term referencing it; the copies are dropped when the term
         // itself is reclaimed.
-        let arg = |i: usize| unsafe { args[i].shared().copy() };
+        self.insert_fixed_iter(symbol, args.iter().map(|arg| unsafe { arg.shared().copy() }))
+    }
+
+    /// Inserts a term whose arity is at most [MAX_FIXED_ARITY], pulling the argument indices
+    /// straight from the iterator. Counterpart of [Self::insert_fixed] for callers that only
+    /// have an iterator and would otherwise round-trip through an intermediate buffer.
+    ///
+    /// The caller produces the `ATermIndex` copies (an unsafe operation) and thereby
+    /// guarantees they stay valid until the inserted term takes ownership of them.
+    ///
+    /// # Panics
+    ///
+    /// Panics when the iterator yields fewer items than the arity of the symbol.
+    pub(crate) fn insert_fixed_iter<'a, 'b, S, I>(
+        &self,
+        symbol: &'b S,
+        mut args: I,
+    ) -> (StablePointer<SharedTerm>, bool)
+    where
+        S: Symb<'a, 'b>,
+        I: Iterator<Item = ATermIndex>,
+    {
+        let mut arg = || {
+            args.next()
+                .expect("The iterator yields fewer arguments than the arity of the symbol")
+        };
 
-        match symbol.arity() {
+        let result = match symbol.arity() {
             0 => {
                 let (result, inserted) = self.terms_0.insert(SharedTermFixed {
                     symbol: SymbolRef::from_symbol(symbol),
@@ -97,66 +164,60 @@ impl ATermStorage {
             1 => {
                 let (result, inserted) = self.terms_1.insert(SharedTermFixed {
                     symbol: SymbolRef::from_symbol(symbol),
-                    args: [arg(0)],
+                    args: [arg()],
                 });
                 unsafe { (cast_to_shared_term_ptr(&result, 1), inserted) }
             }
             2 => {
                 let (result, inserted) = self.terms_2.insert(SharedTermFixed {
                     symbol: SymbolRef::from_symbol(symbol),
-                    args: [arg(0), arg(1)],
+                    args: [arg(), arg()],
                 });
                 unsafe { (cast_to_shared_term_ptr(&result, 2), inserted) }
             }
             3 => {
                 let (result, inserted) = self.terms_3.insert(SharedTermFixed {
                     symbol: SymbolRef::from_symbol(symbol),
-                    args: [arg(0), arg(1), arg(2)],
+                    args: [arg(), arg(), arg()],
                 });
                 unsafe { (cast_to_shared_term_ptr(&result, 3), inserted) }
             }
             4 => {
                 let (result, inserted) = self.terms_4.insert(SharedTermFixed {
                     symbol: SymbolRef::from_symbol(symbol),
-                    args: [arg(0), arg(1), arg(2), arg(3)],
+                    args: [arg(), arg(), arg(), arg()],
                 });
                 unsafe { (cast_to_shared_term_ptr(&result, 4), inserted) }
             }
             5 => {
                 let (result, inserted) = self.terms_5.insert(SharedTermFixed {
                     symbol: SymbolRef::from_symbol(symbol),
-                    args: [arg(0), arg(1), arg(2), arg(3), arg(4)],
+                    args: [arg(), arg(), arg(), arg(), arg()],
                 });
                 unsafe { (cast_to_shared_term_ptr(&result, 5), inserted) }
             }
             6 => {
                 let (result, inserted) = self.terms_6.insert(SharedTermFixed {
                     symbol: SymbolRef::from_symbol(symbol),
-                    args: [arg(0), arg(1), arg(2), arg(3), arg(4), arg(5)],
+                    args: [arg(), arg(), arg(), arg(), arg(), arg()],
                 });
                 unsafe { (cast_to_shared_term_ptr(&result, 6), inserted) }
             }
             7 => {
                 let (result, inserted) = self.terms_7.insert(SharedTermFixed {
                     symbol: SymbolRef::from_symbol(symbol),
-                    args: [arg(0), arg(1), arg(2), arg(3), arg(4), arg(5), arg(6)],
+                    args: [arg(), arg(), arg(), arg(), arg(), arg(), arg()],
                 });
                 unsafe { (cast_to_shared_term_ptr(&result, 7), inserted) }
             }
-            _ => {
-                let shared_term = SharedTermLookup {
-                    symbol: SymbolRef::from_symbol(symbol),
-                    arguments: args,
-                };
-
-                unsafe {
-                    self.terms
-                        .insert_equiv_dst(&shared_term, SharedTerm::length_for(&shared_term), |ptr, key| {
-                            SharedTerm::construct(ptr, key)
-                        })
-                }
-            }
-        }
+            arity => unreachable!("insert_fixed_iter called with arity {arity} > {MAX_FIXED_ARITY}"),
+        };
+
+        debug_assert!(
+            args.next().is_none(),
+            "The iterator yields more arguments than the arity of the symbol"
+        );
+        result
     }
 
     /// Inserts an integer term into the storage, returning a pointer to the stored term

crates/aterm/src/storage/gc_mutex.rs

@@ -10,12 +10,11 @@ use crate::storage::THREAD_TERM_POOL;
 /// the [super::GlobalTermPool] for the duration of the guard's lifetime.
 /// Returns a [GcMutexGuard] on access.
 ///
-/// # Safety
+/// # Panics
 ///
 /// The `GcMutex` returns guards that are tied to the thread-local storage of
 /// [crate::storage::THREAD_TERM_POOL]. This means that the guard must be
-/// dropped before this thread-local storage is dropped. Otherwise
-/// use-after-free will occur, which is undefined behaviour.
+/// dropped before this thread-local storage is dropped, or it will panic.
 pub(crate) struct GcMutex<T> {
     inner: UnsafeCell<T>,
 }

crates/aterm/src/storage/global_aterm_pool.rs

@@ -155,6 +155,38 @@ impl GlobalTermPool {
         self.terms.insert(symbol, args)
     }
 
+    /// Create a term of arity at most [crate::storage::aterm_storage::MAX_FIXED_ARITY] directly
+    /// from the given argument slice, without an intermediate `ATermRef` buffer.
+    ///
+    /// Crate-private: the returned pointer is unprotected, see [Self::create_int].
+    pub(crate) fn create_term_fixed<'a, 'b, 'c, 'd, S, T>(
+        &self,
+        symbol: &'b S,
+        args: &[T],
+    ) -> (StablePointer<SharedTerm>, bool)
+    where
+        S: Symb<'a, 'b>,
+        T: Term<'c, 'd>,
+    {
+        self.terms.insert_fixed(symbol, args)
+    }
+
+    /// Create a term of arity at most [crate::storage::aterm_storage::MAX_FIXED_ARITY] straight
+    /// from an iterator over argument indices, see [Self::create_term_fixed].
+    ///
+    /// Crate-private: the returned pointer is unprotected, see [Self::create_int].
+    pub(crate) fn create_term_fixed_iter<'a, 'b, S, I>(
+        &self,
+        symbol: &'b S,
+        args: I,
+    ) -> (StablePointer<SharedTerm>, bool)
+    where
+        S: Symb<'a, 'b>,
+        I: Iterator<Item = ATermIndex>,
+    {
+        self.terms.insert_fixed_iter(symbol, args)
+    }
+
     /// Create a function symbol
     ///
     /// Crate-private: `protect` receives an unprotected index, see [Self::create_int].