Cargo.toml

@@ -8,6 +8,7 @@ members = [
     "compiler/cl-ast",
     "compiler/cl-parser",
     "compiler/cl-lexer",
+    "compiler/cl-arena",
     "repline",
 ]
 resolver = "2"

compiler/cl-arena/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "cl-arena"
+repository.workspace = true
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+publish.workspace = true
+
+[dependencies]

compiler/cl-arena/src/dropless_arena/tests.rs

@@ -0,0 +1,42 @@
+use super::DroplessArena;
+    extern crate std;
+    use core::alloc::Layout;
+    use std::{prelude::rust_2021::*, vec};
+
+    #[test]
+    fn alloc_raw() {
+        let arena = DroplessArena::new();
+        let bytes = arena.alloc_raw(Layout::for_value(&0u128));
+        let byte2 = arena.alloc_raw(Layout::for_value(&0u128));
+
+        assert_ne!(bytes, byte2);
+    }
+
+    #[test]
+    fn alloc() {
+        let arena = DroplessArena::new();
+        let mut allocations = vec![];
+        for i in 0..0x400 {
+            allocations.push(arena.alloc(i));
+        }
+    }
+
+    #[test]
+    fn alloc_strings() {
+        const KW: &[&str] = &["pub", "mut", "fn", "mod", "conlang", "sidon", "🦈"];
+        let arena = DroplessArena::new();
+        let mut allocations = vec![];
+        for _ in 0..100 {
+            for kw in KW {
+                allocations.push(arena.alloc_str(kw));
+            }
+        }
+    }
+
+    #[test]
+    #[should_panic]
+    fn alloc_zsts() {
+        struct Zst;
+        let arena = DroplessArena::new();
+        arena.alloc(Zst);
+    }

compiler/cl-arena/src/lib.rs

@@ -0,0 +1,396 @@
+//! Typed and dropless arena allocation, paraphrased from [the Rust Compiler's `rustc_arena`](https://github.com/rust-lang/rust/blob/master/compiler/rustc_arena/src/lib.rs). See [LICENSE][1].
+//!
+//! An Arena Allocator is a type of allocator which provides stable locations for allocations within
+//! itself for the entire duration of its lifetime.
+//!
+//! [1]: https://raw.githubusercontent.com/rust-lang/rust/master/LICENSE-MIT
+
+#![feature(dropck_eyepatch, new_uninit, strict_provenance)]
+#![no_std]
+
+extern crate alloc;
+
+pub(crate) mod constants {
+    //! Size constants for arena chunk growth
+    pub(crate) const MIN_CHUNK: usize = 4096;
+    pub(crate) const MAX_CHUNK: usize = 2 * 1024 * 1024;
+}
+
+mod chunk {
+    //! An [ArenaChunk] contains a block of raw memory for use in arena allocators.
+    use alloc::boxed::Box;
+    use core::{
+        mem::{self, MaybeUninit},
+        ptr::{self, NonNull},
+    };
+
+    pub struct ArenaChunk<T> {
+        pub(crate) mem: NonNull<[MaybeUninit<T>]>,
+        pub(crate) filled: usize,
+    }
+
+    impl<T: Sized> ArenaChunk<T> {
+        pub fn new(cap: usize) -> Self {
+            let slice = Box::new_uninit_slice(cap);
+            Self { mem: NonNull::from(Box::leak(slice)), filled: 0 }
+        }
+
+        /// Drops all elements inside self, and resets the filled count to 0
+        ///
+        /// # Safety
+        ///
+        /// The caller must ensure that `self.filled` elements of self are currently initialized
+        pub unsafe fn drop_elements(&mut self) {
+            if mem::needs_drop::<T>() {
+                // Safety: the caller has ensured that `filled` elements are initialized
+                unsafe {
+                    let slice = self.mem.as_mut();
+                    for t in slice[..self.filled].iter_mut() {
+                        t.assume_init_drop();
+                    }
+                }
+                self.filled = 0;
+            }
+        }
+
+        /// Gets a pointer to the start of the arena
+        pub fn start(&mut self) -> *mut T {
+            self.mem.as_ptr() as _
+        }
+
+        /// Gets a pointer to the end of the arena
+        pub fn end(&mut self) -> *mut T {
+            if mem::size_of::<T>() == 0 {
+                ptr::without_provenance_mut(usize::MAX) // pointers to ZSTs must be unique
+            } else {
+                unsafe { self.start().add(self.mem.len()) }
+            }
+        }
+    }
+
+    impl<T> Drop for ArenaChunk<T> {
+        fn drop(&mut self) {
+            let _ = unsafe { Box::from_raw(self.mem.as_ptr()) };
+        }
+    }
+}
+
+pub mod typed_arena {
+    //! A [TypedArena] can hold many instances of a single type, and will properly [Drop] them.
+    #![allow(clippy::mut_from_ref)]
+
+    use crate::{chunk::ArenaChunk, constants::*};
+    use alloc::vec::Vec;
+    use core::{
+        cell::{Cell, RefCell},
+        marker::PhantomData,
+        mem, ptr, slice,
+    };
+
+    /// A [TypedArena] can hold many instances of a single type, and will properly [Drop] them when
+    /// it falls out of scope.
+    pub struct TypedArena<'arena, T> {
+        _lives: PhantomData<&'arena T>,
+        _drops: PhantomData<T>,
+        chunks: RefCell<Vec<ArenaChunk<T>>>,
+        head: Cell<*mut T>,
+        tail: Cell<*mut T>,
+    }
+
+    impl<'arena, T> Default for TypedArena<'arena, T> {
+        fn default() -> Self {
+            Self::new()
+        }
+    }
+
+    impl<'arena, T> TypedArena<'arena, T> {
+        pub const fn new() -> Self {
+            Self {
+                _lives: PhantomData,
+                _drops: PhantomData,
+                chunks: RefCell::new(Vec::new()),
+                head: Cell::new(ptr::null_mut()),
+                tail: Cell::new(ptr::null_mut()),
+            }
+        }
+
+        pub fn alloc(&'arena self, value: T) -> &'arena mut T {
+            if self.head == self.tail {
+                self.grow(1);
+            }
+
+            let out = if mem::size_of::<T>() == 0 {
+                self.head
+                    .set(ptr::without_provenance_mut(self.head.get().addr() + 1));
+                ptr::NonNull::<T>::dangling().as_ptr()
+            } else {
+                let out = self.head.get();
+                self.head.set(unsafe { out.add(1) });
+                out
+            };
+
+            unsafe {
+                ptr::write(out, value);
+                &mut *out
+            }
+        }
+
+        fn can_allocate(&self, len: usize) -> bool {
+            len <= unsafe { self.tail.get().offset_from(self.head.get()) as usize }
+        }
+
+        /// # Panics
+        /// Panics if size_of::<T> == 0 || len == 0
+        #[inline]
+        fn alloc_raw_slice(&self, len: usize) -> *mut T {
+            assert!(mem::size_of::<T>() != 0);
+            assert!(len != 0);
+
+            if !self.can_allocate(len) {
+                self.grow(len)
+            }
+
+            let out = self.head.get();
+
+            unsafe { self.head.set(out.add(len)) };
+            out
+        }
+
+        pub fn alloc_from_iter<I>(&'arena self, iter: I) -> &'arena mut [T]
+        where I: IntoIterator<Item = T> {
+            // Collect them all into a buffer so they're allocated contiguously
+            let mut buf = iter.into_iter().collect::<Vec<_>>();
+            if buf.is_empty() {
+                return &mut [];
+            }
+
+            let len = buf.len();
+            // If T is a ZST, calling alloc_raw_slice will panic
+            let slice = if mem::size_of::<T>() == 0 {
+                self.head
+                    .set(ptr::without_provenance_mut(self.head.get().addr() + len));
+                ptr::NonNull::dangling().as_ptr()
+            } else {
+                self.alloc_raw_slice(len)
+            };
+
+            unsafe {
+                buf.as_ptr().copy_to_nonoverlapping(slice, len);
+                buf.set_len(0);
+                slice::from_raw_parts_mut(slice, len)
+            }
+        }
+
+        #[cold]
+        #[inline(never)]
+        fn grow(&self, len: usize) {
+            let size = mem::size_of::<T>().max(1);
+
+            let mut chunks = self.chunks.borrow_mut();
+
+            let capacity = if let Some(last) = chunks.last_mut() {
+                last.filled = self.get_filled_of_chunk(last);
+                last.mem.len().min(MAX_CHUNK / size) * 2
+            } else {
+                MIN_CHUNK / size
+            }
+            .max(len);
+
+            let mut chunk = ArenaChunk::<T>::new(capacity);
+
+            self.head.set(chunk.start());
+            self.tail.set(chunk.end());
+            chunks.push(chunk);
+        }
+
+        fn get_filled_of_chunk(&self, chunk: &mut ArenaChunk<T>) -> usize {
+            let Self { head: tail, .. } = self;
+            let head = chunk.start();
+            if mem::size_of::<T>() == 0 {
+                tail.get().addr() - head.addr()
+            } else {
+                unsafe { tail.get().offset_from(head) as usize }
+            }
+        }
+    }
+
+    unsafe impl<'arena, T: Send> Send for TypedArena<'arena, T> {}
+
+    unsafe impl<'arena, #[may_dangle] T> Drop for TypedArena<'arena, T> {
+        fn drop(&mut self) {
+            let mut chunks = self.chunks.borrow_mut();
+
+            if let Some(last) = chunks.last_mut() {
+                last.filled = self.get_filled_of_chunk(last);
+                self.tail.set(self.head.get());
+            }
+
+            for chunk in chunks.iter_mut() {
+                unsafe { chunk.drop_elements() }
+            }
+        }
+    }
+
+    #[cfg(test)]
+    mod tests;
+}
+
+pub mod dropless_arena {
+    //! A [DroplessArena] can hold *any* combination of types as long as they don't implement
+    //! [Drop].
+    use crate::{chunk::ArenaChunk, constants::*};
+    use alloc::vec::Vec;
+    use core::{
+        alloc::Layout,
+        cell::{Cell, RefCell},
+        marker::PhantomData,
+        mem, ptr, slice,
+    };
+
+    pub struct DroplessArena<'arena> {
+        _lives: PhantomData<&'arena u8>,
+        chunks: RefCell<Vec<ArenaChunk<u8>>>,
+        head: Cell<*mut u8>,
+        tail: Cell<*mut u8>,
+    }
+
+    impl Default for DroplessArena<'_> {
+        fn default() -> Self {
+            Self::new()
+        }
+    }
+
+    impl<'arena> DroplessArena<'arena> {
+        pub const fn new() -> Self {
+            Self {
+                _lives: PhantomData,
+                chunks: RefCell::new(Vec::new()),
+                head: Cell::new(ptr::null_mut()),
+                tail: Cell::new(ptr::null_mut()),
+            }
+        }
+
+        /// Allocates a `T` in the [DroplessArena], and returns a mutable reference to it.
+        ///
+        /// # Panics
+        /// - Panics if T implements [Drop]
+        /// - Panics if T is zero-sized
+        #[allow(clippy::mut_from_ref)]
+        pub fn alloc<T>(&'arena self, value: T) -> &'arena mut T {
+            assert!(!mem::needs_drop::<T>());
+            assert!(mem::size_of::<T>() != 0);
+
+            let out = self.alloc_raw(Layout::new::<T>()) as *mut T;
+
+            unsafe {
+                ptr::write(out, value);
+                &mut *out
+            }
+        }
+
+        /// Allocates a slice of `T`s`, copied from the given slice, returning a mutable reference
+        /// to it.
+        ///
+        /// # Panics
+        /// - Panics if T implements [Drop]
+        /// - Panics if T is zero-sized
+        /// - Panics if the slice is empty
+        #[allow(clippy::mut_from_ref)]
+        pub fn alloc_slice<T: Copy>(&'arena self, slice: &[T]) -> &'arena mut [T] {
+            assert!(!mem::needs_drop::<T>());
+            assert!(mem::size_of::<T>() != 0);
+            assert!(!slice.is_empty());
+
+            let mem = self.alloc_raw(Layout::for_value::<[T]>(slice)) as *mut T;
+
+            unsafe {
+                mem.copy_from_nonoverlapping(slice.as_ptr(), slice.len());
+                slice::from_raw_parts_mut(mem, slice.len())
+            }
+        }
+
+        /// Allocates a copy of the given [`&str`](str), returning a reference to the allocation.
+        ///
+        /// # Panics
+        /// Panics if the string is empty.
+        pub fn alloc_str(&'arena self, string: &str) -> &'arena str {
+            let slice = self.alloc_slice(string.as_bytes());
+
+            // Safety: This is a clone of the input string, which was valid
+            unsafe { core::str::from_utf8_unchecked(slice) }
+        }
+
+        /// Allocates some [bytes](u8) based on the given [Layout].
+        ///
+        /// # Panics
+        /// Panics if the provided [Layout] has size 0
+        pub fn alloc_raw(&'arena self, layout: Layout) -> *mut u8 {
+            /// Rounds the given size (or pointer value) *up* to the given alignment
+            fn align_up(size: usize, align: usize) -> usize {
+                (size + align - 1) & !(align - 1)
+            }
+            /// Rounds the given size (or pointer value) *down* to the given alignment
+            fn align_down(size: usize, align: usize) -> usize {
+                size & !(align - 1)
+            }
+
+            assert!(layout.size() != 0);
+            loop {
+                let Self { head, tail, .. } = self;
+                let start = head.get().addr();
+                let end = tail.get().addr();
+
+                let align = 8.max(layout.align());
+
+                let bytes = align_up(layout.size(), align);
+
+                if let Some(end) = end.checked_sub(bytes) {
+                    let end = align_down(end, layout.align());
+
+                    if start <= end {
+                        tail.set(tail.get().with_addr(end));
+                        return tail.get();
+                    }
+                }
+
+                self.grow(layout.size());
+            }
+        }
+
+        /// Grows the allocator, doubling the chunk size until it reaches [MAX_CHUNK].
+        #[cold]
+        #[inline(never)]
+        fn grow(&self, len: usize) {
+            let mut chunks = self.chunks.borrow_mut();
+
+            let capacity = if let Some(last) = chunks.last_mut() {
+                last.mem.len().min(MAX_CHUNK / 2) * 2
+            } else {
+                MIN_CHUNK
+            }
+            .max(len);
+
+            let mut chunk = ArenaChunk::<u8>::new(capacity);
+
+            self.head.set(chunk.start());
+            self.tail.set(chunk.end());
+            chunks.push(chunk);
+        }
+
+        /// Checks whether the given slice is allocated in this arena
+        pub fn contains_slice<T>(&self, slice: &[T]) -> bool {
+            let ptr = slice.as_ptr().cast::<u8>().cast_mut();
+            for chunk in self.chunks.borrow_mut().iter_mut() {
+                if chunk.start() <= ptr && ptr <= chunk.end() {
+                    return true;
+                }
+            }
+            false
+        }
+    }
+
+    unsafe impl<'arena> Send for DroplessArena<'arena> {}
+
+    #[cfg(test)]
+    mod tests;
+}

compiler/cl-arena/src/typed_arena/tests.rs

@@ -0,0 +1,61 @@
+use super::TypedArena;
+    extern crate std;
+    use std::{prelude::rust_2021::*, print, vec};
+    #[test]
+    fn pushing_to_arena() {
+        let arena = TypedArena::new();
+        let foo = arena.alloc("foo");
+        let bar = arena.alloc("bar");
+        let baz = arena.alloc("baz");
+
+        assert_eq!("foo", *foo);
+        assert_eq!("bar", *bar);
+        assert_eq!("baz", *baz);
+    }
+
+    #[test]
+    fn pushing_vecs_to_arena() {
+        let arena = TypedArena::new();
+
+        let foo = arena.alloc(vec!["foo"]);
+        let bar = arena.alloc(vec!["bar"]);
+        let baz = arena.alloc(vec!["baz"]);
+
+        assert_eq!("foo", foo[0]);
+        assert_eq!("bar", bar[0]);
+        assert_eq!("baz", baz[0]);
+    }
+
+    #[test]
+    fn pushing_zsts() {
+        struct ZeroSized;
+        impl Drop for ZeroSized {
+            fn drop(&mut self) {
+                print!("")
+            }
+        }
+
+        let arena = TypedArena::new();
+
+        for _ in 0..0x100 {
+            arena.alloc(ZeroSized);
+        }
+    }
+
+    #[test]
+    fn pushing_nodrop_zsts() {
+        struct ZeroSized;
+        let arena = TypedArena::new();
+
+        for _ in 0..0x1000 {
+            arena.alloc(ZeroSized);
+        }
+    }
+    #[test]
+    fn resize() {
+        let arena = TypedArena::new();
+
+        for _ in 0..0x780 {
+            arena.alloc(0u128);
+        }
+    }

compiler/cl-ast/src/ast.rs

@@ -36,7 +36,6 @@ pub enum Literal {
     Bool(bool),
     Char(char),
     Int(u128),
-    Float(u64),
     String(String),
 }
 

compiler/cl-ast/src/ast_impl.rs

@@ -50,7 +50,6 @@ mod display {
                 Literal::Bool(v) => v.fmt(f),
                 Literal::Char(v) => write!(f, "'{}'", v.escape_debug()),
                 Literal::Int(v) => v.fmt(f),
-                Literal::Float(v) => write!(f, "{:?}", f64::from_bits(*v)),
                 Literal::String(v) => write!(f, "\"{}\"", v.escape_debug()),
             }
         }

compiler/cl-ast/src/ast_visitor/fold.rs

@@ -37,9 +37,6 @@ pub trait Fold {
     fn fold_int(&mut self, i: u128) -> u128 {
         i
     }
-    fn fold_smuggled_float(&mut self, f: u64) -> u64 {
-        f
-    }
     fn fold_string(&mut self, s: String) -> String {
         s
     }
@@ -387,7 +384,6 @@ pub fn or_fold_literal<F: Fold + ?Sized>(folder: &mut F, lit: Literal) -> Litera
         Literal::Bool(b) => Literal::Bool(folder.fold_bool(b)),
         Literal::Char(c) => Literal::Char(folder.fold_char(c)),
         Literal::Int(i) => Literal::Int(folder.fold_int(i)),
-        Literal::Float(f) => Literal::Float(folder.fold_smuggled_float(f)),
         Literal::String(s) => Literal::String(folder.fold_string(s)),
     }
 }

compiler/cl-ast/src/ast_visitor/visit.rs

@@ -23,7 +23,6 @@ pub trait Visit<'a>: Sized {
     fn visit_bool(&mut self, _b: &'a bool) {}
     fn visit_char(&mut self, _c: &'a char) {}
     fn visit_int(&mut self, _i: &'a u128) {}
-    fn visit_smuggled_float(&mut self, _f: &'a u64) {}
     fn visit_string(&mut self, _s: &'a str) {}
     fn visit_file(&mut self, f: &'a File) {
         let File { items } = f;
@@ -340,7 +339,6 @@ pub fn or_visit_literal<'a, V: Visit<'a>>(visitor: &mut V, l: &'a Literal) {
         Literal::Bool(b) => visitor.visit_bool(b),
         Literal::Char(c) => visitor.visit_char(c),
         Literal::Int(i) => visitor.visit_int(i),
-        Literal::Float(f) => visitor.visit_smuggled_float(f),
         Literal::String(s) => visitor.visit_string(s),
     }
 }

compiler/cl-ast/src/format.rs

@@ -21,7 +21,7 @@ pub struct Indent<'f, F: Write + ?Sized> {
     f: &'f mut F,
 }
 
-impl<F: Write + ?Sized> Write for Indent<'_, F> {
+impl<'f, F: Write + ?Sized> Write for Indent<'f, F> {
     fn write_str(&mut self, s: &str) -> std::fmt::Result {
         for s in s.split_inclusive('\n') {
             self.f.write_str(s)?;
@@ -45,14 +45,14 @@ impl<'f, F: Write + ?Sized> Delimit<'f, F> {
         Self { f, delim }
     }
 }
-impl<F: Write + ?Sized> Drop for Delimit<'_, F> {
+impl<'f, F: Write + ?Sized> Drop for Delimit<'f, F> {
     fn drop(&mut self) {
         let Self { f: Indent { f, .. }, delim } = self;
         let _ = f.write_str(delim.close);
     }
 }
 
-impl<F: Write + ?Sized> Write for Delimit<'_, F> {
+impl<'f, F: Write + ?Sized> Write for Delimit<'f, F> {
     fn write_str(&mut self, s: &str) -> std::fmt::Result {
         self.f.write_str(s)
     }

compiler/cl-interpret/src/builtin.rs

@@ -223,7 +223,6 @@ builtins! {
         Ok(match tail {
             ConValue::Empty => ConValue::Empty,
             ConValue::Int(v) => ConValue::Int(v.wrapping_neg()),
-            ConValue::Float(v) => ConValue::Float(-v),
             _ => Err(Error::TypeError)?,
         })
     }

compiler/cl-interpret/src/convalue.rs

@@ -20,8 +20,6 @@ pub enum ConValue {
     Empty,
     /// An integer
     Int(Integer),
-    /// A floating point number
-    Float(f64),
     /// A boolean
     Bool(bool),
     /// A unicode character
@@ -126,7 +124,6 @@ macro cmp ($($fn:ident: $empty:literal, $op:tt);*$(;)?) {$(
         match (self, other) {
             (Self::Empty, Self::Empty) => Ok(Self::Bool($empty)),
             (Self::Int(a), Self::Int(b)) => Ok(Self::Bool(a $op b)),
-            (Self::Float(a), Self::Float(b)) => Ok(Self::Bool(a $op b)),
             (Self::Bool(a), Self::Bool(b)) => Ok(Self::Bool(a $op b)),
             (Self::Char(a), Self::Char(b)) => Ok(Self::Bool(a $op b)),
             (Self::String(a), Self::String(b)) => Ok(Self::Bool(&**a $op &**b)),
@@ -153,7 +150,6 @@ impl From<&Sym> for ConValue {
 }
 from! {
     Integer => ConValue::Int,
-    f64 => ConValue::Float,
     bool => ConValue::Bool,
     char => ConValue::Char,
     Sym => ConValue::String,
@@ -193,8 +189,7 @@ ops! {
     Add: add = [
         (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
         (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a.wrapping_add(b)),
-        (ConValue::Float(a), ConValue::Float(b)) => ConValue::Float(a + b),
-        (ConValue::String(a), ConValue::String(b)) => (a.to_string() + &*b).into(),
+        (ConValue::String(a), ConValue::String(b)) => (a.to_string() + &b.to_string()).into(),
         (ConValue::String(s), ConValue::Char(c)) => { let mut s = s.to_string(); s.push(c); s.into() }
         (ConValue::Char(a), ConValue::Char(b)) => {
             ConValue::String([a, b].into_iter().collect::<String>().into())
@@ -224,21 +219,18 @@ ops! {
         (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a.checked_div(b).unwrap_or_else(|| {
             eprintln!("Warning: Divide by zero in {a} / {b}"); a
         })),
-        (ConValue::Float(a), ConValue::Float(b)) => ConValue::Float(a / b),
         _ => Err(Error::TypeError)?
     ]
     Mul: mul = [
         (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
         (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a.wrapping_mul(b)),
-        (ConValue::Float(a), ConValue::Float(b)) => ConValue::Float(a * b),
         _ => Err(Error::TypeError)?
     ]
     Rem: rem = [
         (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
         (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a.checked_rem(b).unwrap_or_else(|| {
-            println!("Warning: Divide by zero in {a} % {b}"); a
+            eprintln!("Warning: Divide by zero in {a} % {b}"); a
         })),
-        (ConValue::Float(a), ConValue::Float(b)) => ConValue::Float(a % b),
         _ => Err(Error::TypeError)?
     ]
     Shl: shl = [
@@ -254,7 +246,6 @@ ops! {
     Sub: sub = [
         (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
         (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a.wrapping_sub(b)),
-        (ConValue::Float(a), ConValue::Float(b)) => ConValue::Float(a - b),
         _ => Err(Error::TypeError)?
     ]
 }
@@ -263,7 +254,6 @@ impl std::fmt::Display for ConValue {
         match self {
             ConValue::Empty => "Empty".fmt(f),
             ConValue::Int(v) => v.fmt(f),
-            ConValue::Float(v) => v.fmt(f),
             ConValue::Bool(v) => v.fmt(f),
             ConValue::Char(v) => v.fmt(f),
             ConValue::String(v) => v.fmt(f),

compiler/cl-interpret/src/env.rs

@@ -147,18 +147,18 @@ impl<'scope> Frame<'scope> {
         Self { scope: scope.enter(name) }
     }
 }
-impl Deref for Frame<'_> {
+impl<'scope> Deref for Frame<'scope> {
     type Target = Environment;
     fn deref(&self) -> &Self::Target {
         self.scope
     }
 }
-impl DerefMut for Frame<'_> {
+impl<'scope> DerefMut for Frame<'scope> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.scope
     }
 }
-impl Drop for Frame<'_> {
+impl<'scope> Drop for Frame<'scope> {
     fn drop(&mut self) {
         self.scope.exit();
     }

compiler/cl-interpret/src/interpret.rs

@@ -358,9 +358,6 @@ fn cast(value: ConValue, ty: Sym) -> IResult<ConValue> {
         ConValue::Bool(b) => b as _,
         ConValue::Char(c) => c as _,
         ConValue::Ref(v) => return cast((*v).clone(), ty),
-        // TODO: This, better
-        ConValue::Float(_) if ty.starts_with('f') => return Ok(value),
-        ConValue::Float(f) => f as _,
         _ => Err(Error::TypeError)?,
     };
     Ok(match &*ty {
@@ -372,8 +369,6 @@ fn cast(value: ConValue, ty: Sym) -> IResult<ConValue> {
         "i32" => ConValue::Int(value as i32 as _),
         "u64" => ConValue::Int(value),
         "i64" => ConValue::Int(value),
-        "f32" => ConValue::Float(value as f32 as _),
-        "f64" => ConValue::Float(value as f64 as _),
         "char" => ConValue::Char(char::from_u32(value as _).unwrap_or('\u{fffd}')),
         "bool" => ConValue::Bool(value < 0),
         _ => Err(Error::NotDefined(ty))?,
@@ -453,7 +448,7 @@ impl Interpret for Literal {
             Literal::String(value) => ConValue::from(value.as_str()),
             Literal::Char(value) => ConValue::Char(*value),
             Literal::Bool(value) => ConValue::Bool(*value),
-            Literal::Float(value) => ConValue::Float(f64::from_bits(*value)),
+            // Literal::Float(value) => todo!("Float values in interpreter: {value:?}"),
             Literal::Int(value) => ConValue::Int(*value as _),
         })
     }

compiler/cl-interpret/src/tests.rs

@@ -1,5 +1,5 @@
 #![allow(unused_imports)]
-use crate::{convalue::ConValue, env::Environment, Interpret};
+use crate::{env::Environment, convalue::ConValue, Interpret};
 use cl_ast::*;
 use cl_lexer::Lexer;
 use cl_parser::Parser;
@@ -188,7 +188,7 @@ mod fn_declarations {
         assert_eval!(env, fn empty_fn() {});
         // TODO: true equality for functions
         assert_eq!(
-            "fn empty_fn () {}",
+            "fn empty_fn () {\n    \n}",
             format!(
                 "{}",
                 env.get("empty_fn".into())

compiler/cl-lexer/src/lib.rs

@@ -23,7 +23,7 @@ pub mod lexer_iter {
     pub struct LexerIter<'t> {
         lexer: Lexer<'t>,
     }
-    impl Iterator for LexerIter<'_> {
+    impl<'t> Iterator for LexerIter<'t> {
         type Item = LResult<Token>;
         fn next(&mut self) -> Option<Self::Item> {
             match self.lexer.scan() {
@@ -192,7 +192,7 @@ impl<'t> Lexer<'t> {
     }
 }
 /// Digraphs and trigraphs
-impl Lexer<'_> {
+impl<'t> Lexer<'t> {
     fn amp(&mut self) -> LResult<Token> {
         match self.peek() {
             Ok('&') => self.consume()?.produce_op(Kind::AmpAmp),
@@ -319,7 +319,7 @@ impl Lexer<'_> {
     }
 }
 /// Comments
-impl Lexer<'_> {
+impl<'t> Lexer<'t> {
     fn line_comment(&mut self) -> LResult<Token> {
         let mut comment = String::new();
         while Ok('\n') != self.peek() {
@@ -339,7 +339,7 @@ impl Lexer<'_> {
     }
 }
 /// Identifiers
-impl Lexer<'_> {
+impl<'t> Lexer<'t> {
     fn identifier(&mut self) -> LResult<Token> {
         let mut out = String::from(self.xid_start()?);
         while let Ok(c) = self.xid_continue() {
@@ -371,39 +371,23 @@ impl Lexer<'_> {
     }
 }
 /// Integers
-impl Lexer<'_> {
+impl<'t> Lexer<'t> {
     fn int_with_base(&mut self) -> LResult<Token> {
         match self.peek() {
             Ok('x') => self.consume()?.digits::<16>(),
             Ok('d') => self.consume()?.digits::<10>(),
             Ok('o') => self.consume()?.digits::<8>(),
             Ok('b') => self.consume()?.digits::<2>(),
-            Ok('0'..='9' | '.') => self.digits::<10>(),
+            Ok('0'..='9') => self.digits::<10>(),
             _ => self.produce(Kind::Literal, 0),
         }
     }
     fn digits<const B: u32>(&mut self) -> LResult<Token> {
-        let mut value = 0;
+        let mut value = self.digit::<B>()? as u128;
         while let Ok(true) = self.peek().as_ref().map(char::is_ascii_alphanumeric) {
             value = value * B as u128 + self.digit::<B>()? as u128;
         }
-        // TODO: find a better way to handle floats in the tokenizer
-        match self.peek() {
-            Ok('.') => {
-                // FIXME: hack: 0.. is not [0.0, '.']
-                if let Ok('.') = self.clone().consume()?.next() {
-                    return self.produce(Kind::Literal, value);
-                }
-                let mut float = format!("{value}.");
-                self.consume()?;
-                while let Ok(true) = self.peek().as_ref().map(char::is_ascii_digit) {
-                    float.push(self.iter.next().unwrap_or_default());
-                }
-                let float = f64::from_str(&float).expect("must be parsable as float");
-                self.produce(Kind::Literal, float)
-            }
-            _ => self.produce(Kind::Literal, value),
-        }
+        self.produce(Kind::Literal, value)
     }
     fn digit<const B: u32>(&mut self) -> LResult<u32> {
         let digit = self.peek()?;
@@ -414,7 +398,7 @@ impl Lexer<'_> {
     }
 }
 /// Strings and characters
-impl Lexer<'_> {
+impl<'t> Lexer<'t> {
     fn string(&mut self) -> LResult<Token> {
         let mut value = String::new();
         while '"'

compiler/cl-parser/src/parser.rs

@@ -245,7 +245,7 @@ impl Parse<'_> for Literal {
             TokenData::String(v) => Literal::String(v),
             TokenData::Character(v) => Literal::Char(v),
             TokenData::Integer(v) => Literal::Int(v),
-            TokenData::Float(v) => Literal::Float(v.to_bits()),
+            TokenData::Float(v) => todo!("Literal::Float({v})"),
             _ => panic!("Expected token data for {ty:?}"),
         })
     }

compiler/cl-parser/src/parser/prec.rs

@@ -247,9 +247,9 @@ fn structor_body(p: &mut Parser, to: Path) -> PResult<Structor> {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum Precedence {
     Assign,
-    Logic,
     Compare,
     Range,
+    Logic,
     Bitwise,
     Shift,
     Factor,

compiler/cl-repl/examples/yaml.rs

@@ -120,19 +120,19 @@ pub mod yamler {
         }
     }
 
-    impl Deref for Section<'_> {
+    impl<'y> Deref for Section<'y> {
         type Target = Yamler;
         fn deref(&self) -> &Self::Target {
             self.yamler
         }
     }
-    impl DerefMut for Section<'_> {
+    impl<'y> DerefMut for Section<'y> {
         fn deref_mut(&mut self) -> &mut Self::Target {
             self.yamler
         }
     }
 
-    impl Drop for Section<'_> {
+    impl<'y> Drop for Section<'y> {
         fn drop(&mut self) {
             let Self { yamler } = self;
             yamler.decrease();

compiler/cl-structures/Cargo.toml

@@ -8,4 +8,4 @@ license.workspace = true
 publish.workspace = true
 
 [dependencies]
-cl-arena = { version = "0", registry = "soft-fish" }
+cl-arena = { path = "../cl-arena" }

compiler/cl-structures/src/index_map.rs

@@ -106,7 +106,7 @@ impl<V, K: MapIndex> IndexMap<K, V> {
     pub fn get_many_mut<const N: usize>(
         &mut self,
         indices: [K; N],
-    ) -> Result<[&mut V; N], GetManyMutError> {
+    ) -> Result<[&mut V; N], GetManyMutError<N>> {
         self.map.get_many_mut(indices.map(|id| id.get()))
     }
 

compiler/cl-structures/src/intern.rs

@@ -35,14 +35,9 @@ pub mod interned {
         pub fn as_ptr(interned: &Self) -> *const T {
             interned.value
         }
-
-        /// Gets the internal value as a reference with the interner's lifetime
-        pub fn to_ref(interned: &Self) -> &'a T {
-            interned.value
-        }
     }
 
-    impl<T: ?Sized + Debug> Debug for Interned<'_, T> {
+    impl<'a, T: ?Sized + Debug> Debug for Interned<'a, T> {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             f.debug_struct("Interned")
                 .field("value", &self.value)
@@ -54,14 +49,14 @@ pub mod interned {
             Self { value }
         }
     }
-    impl<T: ?Sized> Deref for Interned<'_, T> {
+    impl<'a, T: ?Sized> Deref for Interned<'a, T> {
         type Target = T;
         fn deref(&self) -> &Self::Target {
             self.value
         }
     }
-    impl<T: ?Sized> Copy for Interned<'_, T> {}
-    impl<T: ?Sized> Clone for Interned<'_, T> {
+    impl<'a, T: ?Sized> Copy for Interned<'a, T> {}
+    impl<'a, T: ?Sized> Clone for Interned<'a, T> {
         fn clone(&self) -> Self {
             *self
         }
@@ -84,13 +79,13 @@ pub mod interned {
     //     }
     // }
 
-    impl<T: ?Sized> Eq for Interned<'_, T> {}
-    impl<T: ?Sized> PartialEq for Interned<'_, T> {
+    impl<'a, T: ?Sized> Eq for Interned<'a, T> {}
+    impl<'a, T: ?Sized> PartialEq for Interned<'a, T> {
         fn eq(&self, other: &Self) -> bool {
             std::ptr::eq(self.value, other.value)
         }
     }
-    impl<T: ?Sized> Hash for Interned<'_, T> {
+    impl<'a, T: ?Sized> Hash for Interned<'a, T> {
         fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
             Self::as_ptr(self).hash(state)
         }
@@ -124,7 +119,6 @@ pub mod string_interner {
     };
 
     /// A string interner hands out [Interned] copies of each unique string given to it.
-    #[derive(Default)]
     pub struct StringInterner<'a> {
         arena: DroplessArena<'a>,
         keys: RwLock<HashSet<&'a str>>,
@@ -213,8 +207,8 @@ pub mod string_interner {
     // This is fine because StringInterner::get_or_insert(v) holds a RwLock
     // for its entire duration, and doesn't touch the non-(Send+Sync) arena
     // unless the lock is held by a write guard.
-    unsafe impl Send for StringInterner<'_> {}
-    unsafe impl Sync for StringInterner<'_> {}
+    unsafe impl<'a> Send for StringInterner<'a> {}
+    unsafe impl<'a> Sync for StringInterner<'a> {}
 
     #[cfg(test)]
     mod tests {
@@ -264,7 +258,6 @@ pub mod typed_interner {
     /// A [TypedInterner] hands out [Interned] references for arbitrary types.
     ///
     /// See the [module-level documentation](self) for more information.
-    #[derive(Default)]
     pub struct TypedInterner<'a, T: Eq + Hash> {
         arena: TypedArena<'a, T>,
         keys: RwLock<HashSet<&'a T>>,
@@ -311,5 +304,5 @@ pub mod typed_interner {
     /// [get_or_insert](TypedInterner::get_or_insert) are unique, and the function uses
     /// the [RwLock] around the [HashSet] to ensure mutual exclusion
     unsafe impl<'a, T: Eq + Hash + Send> Send for TypedInterner<'a, T> where &'a T: Send {}
-    unsafe impl<T: Eq + Hash + Send + Sync> Sync for TypedInterner<'_, T> {}
+    unsafe impl<'a, T: Eq + Hash + Send + Sync> Sync for TypedInterner<'a, T> {}
 }

compiler/cl-typeck/examples/typeck.rs

@@ -1,3 +1,4 @@
+use cl_structures::intern::string_interner::StringInterner;
 use cl_typeck::{entry::Entry, stage::*, table::Table, type_expression::TypeExpression};
 
 use cl_ast::{
@@ -7,12 +8,10 @@ use cl_ast::{
 };
 use cl_lexer::Lexer;
 use cl_parser::{inliner::ModuleInliner, Parser};
-use cl_structures::intern::string_interner::StringInterner;
 use repline::{error::Error as RlError, prebaked::*};
 use std::{
     error::Error,
     path::{self, PathBuf},
-    sync::LazyLock,
 };
 
 // Path to display in standard library errors
@@ -31,6 +30,11 @@ const C_BYID: &str = "\x1b[95m";
 const C_ERROR: &str = "\x1b[31m";
 const C_LISTING: &str = "\x1b[38;5;117m";
 
+/// A home for immutable intermediate ASTs
+///
+/// TODO: remove this.
+static mut TREES: TreeManager = TreeManager::new();
+
 fn main() -> Result<(), Box<dyn Error>> {
     let mut prj = Table::default();
 
@@ -44,7 +48,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     };
     // This code is special - it gets loaded from a hard-coded project directory (for now)
     let code = inline_modules(code, concat!(env!("CARGO_MANIFEST_DIR"), "/../../stdlib"));
-    Populator::new(&mut prj).visit_file(interned(code));
+    Populator::new(&mut prj).visit_file(unsafe { TREES.push(code) });
 
     main_menu(&mut prj)?;
     Ok(())
@@ -94,8 +98,8 @@ fn enter_code(prj: &mut Table) -> Result<(), RlError> {
         let code = Parser::new(Lexer::new(line)).parse()?;
         let code = inline_modules(code, "");
         let code = WhileElseDesugar.fold_file(code);
-
-        Populator::new(prj).visit_file(interned(code));
+        // Safety: this is totally unsafe
+        Populator::new(prj).visit_file(unsafe { TREES.push(code) });
         Ok(Response::Accept)
     })
 }
@@ -218,7 +222,7 @@ fn import_files(table: &mut Table) -> Result<(), RlError> {
             }
         };
 
-        Populator::new(table).visit_file(interned(code));
+        Populator::new(table).visit_file(unsafe { TREES.push(code) });
 
         println!("...Imported!");
         Ok(Response::Accept)
@@ -318,11 +322,18 @@ fn banner() {
     );
 }
 
-/// Interns a [File](cl_ast::File), returning a static reference to it.
-fn interned(file: cl_ast::File) -> &'static cl_ast::File {
-    use cl_structures::intern::{interned::Interned, typed_interner::TypedInterner};
-    static INTERNER: LazyLock<TypedInterner<'static, cl_ast::File>> =
-        LazyLock::new(Default::default);
-
-    Interned::to_ref(&INTERNER.get_or_insert(file))
+/// Keeps leaked references to past ASTs, for posterity:tm:
+struct TreeManager {
+    trees: Vec<&'static cl_ast::File>,
+}
+
+impl TreeManager {
+    const fn new() -> Self {
+        Self { trees: vec![] }
+    }
+    fn push(&mut self, tree: cl_ast::File) -> &'static cl_ast::File {
+        let ptr = Box::leak(Box::new(tree));
+        self.trees.push(ptr);
+        ptr
+    }
 }

compiler/cl-typeck/src/source.rs

@@ -20,7 +20,7 @@ pub enum Source<'a> {
     Ty(&'a TyKind),
 }
 
-impl Source<'_> {
+impl<'a> Source<'a> {
     pub fn name(&self) -> Option<Sym> {
         match self {
             Source::Root => None,

compiler/cl-typeck/src/table.rs

@@ -268,7 +268,7 @@ impl<'a> Table<'a> {
     }
 }
 
-impl Default for Table<'_> {
+impl<'a> Default for Table<'a> {
     fn default() -> Self {
         Self::new()
     }

repline/examples/repl_float.rs

@@ -1,17 +0,0 @@
-//! Demonstrates the use of [read_and()]:
-//! 
-//! The provided closure:
-//! 1. Takes a line of input (a [String])
-//! 2. Performs some calculation (using [FromStr])
-//! 3. Returns a [Result] containing a [Response] or an [Err]
-
-use repline::{prebaked::read_and, Response};
-use std::{error::Error, str::FromStr};
-
-fn main() -> Result<(), Box<dyn Error>> {
-    read_and("\x1b[33m", "  >", " ?>", |line| {
-        println!("-> {:?}", f64::from_str(line.trim())?);
-        Ok(Response::Accept)
-    })?;
-    Ok(())
-}

repline/src/editor.rs

@@ -302,7 +302,7 @@ impl<'a> Editor<'a> {
     }
 }
 
-impl<'e> IntoIterator for &'e Editor<'_> {
+impl<'a, 'e> IntoIterator for &'e Editor<'a> {
     type Item = &'e char;
     type IntoIter = std::iter::Chain<
         std::collections::vec_deque::Iter<'e, char>,
@@ -313,7 +313,7 @@ impl<'e> IntoIterator for &'e Editor<'_> {
     }
 }
 
-impl Display for Editor<'_> {
+impl<'a> Display for Editor<'a> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         use std::fmt::Write;
         for c in self.iter() {

repline/src/iter.rs

@@ -39,7 +39,7 @@ pub mod chars {
                 if cont & 0xc0 != 0x80 {
                     return None;
                 }
-                out = (out << 6) | (cont & 0x3f);
+                out = out << 6 | (cont & 0x3f);
             }
             Some(char::from_u32(out).ok_or(BadUnicode(out)))
         }

sample-code/sqrt.cl

@@ -1,56 +0,0 @@
-#!/usr/bin/env conlang-run
-//! Square root approximation, and example applications
-
-/// A really small nonzero number
-const EPSILON: f64 = 8.8541878188 / 1000000000000.0;
-
-/// Calcuates the absolute value of a number
-fn f64_abs(n: f64) -> f64 {
-    let n = n as f64
-    if n < (0.0) { -n } else { n }
-}
-
-/// Square root approximation using Newton's method
-fn sqrt(n: f64) -> f64 {
-    let n = n as f64
-    if n < 0.0 {
-        return 0.0 / 0.0 // TODO: NaN constant
-    }
-    if n == 0.0 {
-        return 0.0
-    }
-
-    let z = n
-    loop {
-        let adj = (z * z - n) / (2.0 * z)
-        z -= adj
-        if adj.f64_abs() < EPSILON {
-            break z;
-        }
-    }
-}
-
-/// Pythagorean theorem: a² + b² = c²
-fn pythag(a: f64, b: f64) -> f64 {
-    sqrt(a * a + b * b)
-}
-
-/// Quadratic formula: (-b ± √(b² - 4ac)) / 2a
-fn quadratic(a: f64, b: f64, c: f64) -> (f64, f64) {
-    let a = a as f64; let b = b as f64; let c = c as f64;
-    (
-        (-b + sqrt(b * b - 4.0 * a * c)) / 2.0 * a,
-        (-b - sqrt(b * b - 4.0 * a * c)) / 2.0 * a,
-    )
-}
-
-fn main() {
-    for i in 0..10 {
-        println("sqrt(",i,") ≅ ",sqrt(i as f64))
-    }
-    println("\nPythagorean Theorem")
-    println("Hypotenuse of ⊿(5, 12): ", pythag(5.0, 12.0))
-
-    println("\nQuadratic formula")
-    println("Roots of 10x² + 4x - 1: ", quadratic(10.0, 40, -1.0))
-}