Lots of code simplificationHEADmaster

8 files changed, 70 insertions, 684 deletions

diff --git a/oryxc/src/arena.rs b/oryxc/src/arena.rs
deleted file mode 100644
index cb05908..0000000
--- a/oryxc/src/arena.rs
+++ /dev/null
@@ -1,265 +0,0 @@
-use std::alloc::{
-	self,
-	Layout,
-};
-use std::cell::{
-	Cell,
-	RefCell,
-};
-use std::ptr::{
-	self,
-	NonNull,
-};
-use std::slice;
-use std::sync::Mutex;
-
-use crate::err;
-
-#[derive(Copy, Clone)]
-struct RawBlock {
-	ptr:    NonNull<u8>,
-	layout: Layout,
-}
-
-unsafe impl Send for RawBlock {}
-unsafe impl Sync for RawBlock {}
-
-pub struct GlobalArena {
-	blksz:  usize,
-	blocks: Mutex<Vec<RawBlock>>,
-}
-
-impl GlobalArena {
-	pub fn new(blksz: usize) -> Self {
-		return Self {
-			blksz,
-			blocks: Mutex::new(Vec::new()),
-		};
-	}
-
-	fn allocate_block(&self, layout: Layout) -> RawBlock {
-		let layout = Layout::from_size_align(
-			layout.size().max(self.blksz),
-			layout.align().max(16),
-		)
-		.unwrap_or_else(|e| err!(e, "allocation error"));
-		let ptr = NonNull::new(unsafe { alloc::alloc(layout) })
-			.unwrap_or_else(|| alloc::handle_alloc_error(layout));
-
-		let block = RawBlock { ptr, layout };
-		self.blocks.lock().unwrap().push(block.clone());
-		return block;
-	}
-}
-
-impl Drop for GlobalArena {
-	fn drop(&mut self) {
-		for block in self.blocks.lock().unwrap().iter() {
-			unsafe {
-				alloc::dealloc(block.ptr.as_ptr(), block.layout);
-			}
-		}
-	}
-}
-
-#[derive(Clone, Copy)]
-pub struct Mark {
-	blk: usize,
-	beg: *mut u8,
-	end: *mut u8,
-}
-
-pub struct LocalArena<'a> {
-	parent:        &'a GlobalArena,
-	beg:           Cell<*mut u8>,
-	end:           Cell<*mut u8>,
-	curblk:        Cell<usize>,
-	blks:          RefCell<Vec<RawBlock>>,
-	#[cfg(debug_assertions)]
-	pub waterline: Cell<usize>,
-}
-
-impl<'a> LocalArena<'a> {
-	pub fn new(parent: &'a GlobalArena) -> Self {
-		return Self {
-			parent,
-			beg: Cell::new(ptr::null_mut()),
-			end: Cell::new(ptr::null_mut()),
-			curblk: Cell::new(usize::MAX),
-			blks: RefCell::new(Vec::new()),
-			#[cfg(debug_assertions)]
-			waterline: Cell::new(0),
-		};
-	}
-
-	fn alloc_raw(&self, layout: Layout) -> NonNull<u8> {
-		if cfg!(debug_assertions) {
-			self.waterline.update(|x| x + layout.size());
-		}
-
-		let beg = self.beg.get() as usize;
-
-		let align_offset =
-			beg.wrapping_add(layout.align() - 1) & !(layout.align() - 1);
-		let Some(next_beg) = align_offset.checked_add(layout.size()) else {
-			err!("allocation overflow");
-		};
-
-		return if next_beg <= self.end.get() as usize {
-			self.beg.set(next_beg as *mut u8);
-			unsafe { NonNull::new_unchecked(align_offset as *mut u8) }
-		} else {
-			self.alloc_slow(layout)
-		};
-	}
-
-	#[cold]
-	fn alloc_slow(&self, layout: Layout) -> NonNull<u8> {
-		let mut blks = self.blks.borrow_mut();
-		let next_blk = self.curblk.get().wrapping_add(1);
-
-		/* Find the next recycleable block that fits */
-		let mut found_blk = None;
-		let mut align_beg = 0;
-		for i in next_blk..blks.len() {
-			let blk = &blks[i];
-			let beg = blk.ptr.as_ptr() as usize;
-			let end = beg + blk.layout.size();
-			let aligned =
-				beg.wrapping_add(layout.align() - 1) & !(layout.align() - 1);
-			if aligned.checked_add(layout.size()).unwrap_or(usize::MAX) <= end {
-				found_blk = Some(i);
-				align_beg = aligned;
-				break;
-			}
-		}
-
-		if let Some(i) = found_blk {
-			blks.swap(next_blk, i);
-
-			let blk = &blks[next_blk];
-			let end = blk.ptr.as_ptr() as usize + blk.layout.size();
-
-			self.curblk.set(next_blk);
-			self.beg.set((align_beg + layout.size()) as *mut u8);
-			self.end.set(end as *mut u8);
-
-			return unsafe { NonNull::new_unchecked(align_beg as *mut u8) };
-		}
-
-		let blk = self.parent.allocate_block(layout);
-		let beg = blk.ptr.as_ptr() as usize;
-		let end = beg + blk.layout.size();
-		let align_beg =
-			beg.wrapping_add(layout.align() - 1) & !(layout.align() - 1);
-
-		blks.push(blk);
-		let last_blk = blks.len() - 1;
-		blks.swap(next_blk, last_blk);
-
-		self.curblk.set(next_blk);
-		self.beg.set((align_beg + layout.size()) as *mut u8);
-		self.end.set(end as *mut u8);
-
-		unsafe { NonNull::new_unchecked(align_beg as *mut u8) }
-	}
-
-	pub fn alloc<T>(&self, value: T) -> &'a mut T {
-		let ptr = self.alloc_raw(Layout::new::<T>()).cast::<T>().as_ptr();
-		unsafe {
-			ptr::write(ptr, value);
-			return &mut *ptr;
-		}
-	}
-
-	pub fn alloc_slice<T>(&self, len: usize) -> &'a mut [T] {
-		let layout = Layout::array::<T>(len)
-			.unwrap_or_else(|e| err!(e, "allocation error"));
-		let ptr = self.alloc_raw(layout).cast::<T>().as_ptr();
-		return unsafe { slice::from_raw_parts_mut(ptr, len) };
-	}
-
-	pub fn mark(&self) -> Mark {
-		return Mark {
-			blk: self.curblk.get(),
-			beg: self.beg.get(),
-			end: self.end.get(),
-		};
-	}
-
-	pub fn restore(&self, mark: Mark) {
-		self.curblk.set(mark.blk);
-		self.beg.set(mark.beg);
-		self.end.set(mark.end);
-	}
-
-	pub fn scope<'s, R, F>(&'s mut self, f: F) -> R
-	where
-		F: FnOnce(&ScopedArena<'s, 'a>) -> R,
-	{
-		let m = self.mark();
-		let r = f(&ScopedArena { inner: self });
-		self.restore(m);
-		return r;
-	}
-}
-
-/// A wrapper around LocalArena that bounds returned references to 's.
-pub struct ScopedArena<'s, 'a> {
-	inner: &'s LocalArena<'a>,
-}
-
-impl<'s, 'a> ScopedArena<'s, 'a> {
-	pub fn alloc<T>(&self, value: T) -> &'s mut T {
-		return self.inner.alloc(value);
-	}
-
-	pub fn alloc_slice<T>(&self, len: usize) -> &'s mut [T] {
-		return self.inner.alloc_slice(len);
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use super::{
-		GlobalArena,
-		LocalArena,
-	};
-
-	#[test]
-	fn test_alloc_slice() {
-		let arena_global = GlobalArena::new(8);
-		let arena_local_1 = LocalArena::new(&arena_global);
-		let arena_local_2 = LocalArena::new(&arena_global);
-
-		let s1 = arena_local_1.alloc_slice(8);
-		let s2 = arena_local_2.alloc_slice(4);
-		assert_eq!(s1.len(), 8);
-		assert_eq!(s2.len(), 4);
-
-		for i in 0..s1.len() {
-			s1[i] = i;
-		}
-		for i in 0..s2.len() {
-			s2[i] = i;
-		}
-	}
-
-	#[test]
-	fn test_arena_grows() {
-		let arena_global = GlobalArena::new(8);
-		let arena_local = LocalArena::new(&arena_global);
-
-		let s1 = arena_local.alloc_slice(8);
-		let s2 = arena_local.alloc_slice(69);
-		assert_eq!(s1.len(), 8);
-		assert_eq!(s2.len(), 69);
-
-		for i in 0..s1.len() {
-			s1[i] = i;
-		}
-		for i in 0..s2.len() {
-			s2[i] = i;
-		}
-	}
-}
diff --git a/oryxc/src/compiler.rs b/oryxc/src/compiler.rs
index 8ad00fb..6119915 100644
--- a/oryxc/src/compiler.rs
+++ b/oryxc/src/compiler.rs
@@ -20,7 +20,6 @@ use std::{
 	thread,
 };
 
-use boxcar;
 use crossbeam_deque::{
 	Injector,
 	Steal,
@@ -29,19 +28,10 @@ use crossbeam_deque::{
 };
 use soa_rs::Soa;
 
-use crate::arena::{
-	GlobalArena,
-	LocalArena,
-};
-use crate::depmap::DepMap;
 use crate::errors::OryxError;
-use crate::hashtrie::HTrie;
 use crate::intern::Interner;
 use crate::lexer::Token;
-use crate::parser::{
-	Ast,
-	AstType,
-};
+use crate::parser::Ast;
 use crate::prelude::*;
 use crate::unistr::UniStr;
 use crate::{
@@ -49,7 +39,6 @@ use crate::{
 	err,
 	lexer,
 	parser,
-	size,
 };
 
 #[allow(dead_code)]
@@ -58,7 +47,7 @@ pub struct FileData {
 	pub buffer: String,
 	pub tokens: OnceLock<Soa<Token>>,
 	pub ast:    OnceLock<Ast>,
-	pub scopes: OnceLock<HTrie<ScopeId, Scope>>,
+	pub scopes: OnceLock<Vec<Scope>>,
 }
 
 impl FileData {
@@ -87,24 +76,8 @@ impl FileData {
 #[allow(dead_code)]
 #[derive(Clone)]
 pub enum JobType {
-	Lex {
-		file:  FileId,
-		fdata: Arc<FileData>,
-	},
-	Parse {
-		file:  FileId,
-		fdata: Arc<FileData>,
-	},
-	IndexScopeConstants {
-		fdata:  Arc<FileData>,
-		block:  u32,
-		parent: ScopeId,
-	},
-	ResolveDefBind {
-		fdata: Arc<FileData>,
-		node:  u32,
-		scope: ScopeId,
-	},
+	Lex { file: FileId, fdata: Arc<FileData> },
+	Parse { file: FileId, fdata: Arc<FileData> },
 }
 
 mkidtype!(JobId);
@@ -117,7 +90,6 @@ pub struct Job {
 
 struct CompilerState<'a> {
 	#[allow(dead_code)]
-	global_arena:   GlobalArena,
 	globalq:        Injector<Job>,
 	njobs:          AtomicUsize,
 	flags:          Flags,
@@ -128,9 +100,7 @@ struct CompilerState<'a> {
 	 * order to avoid any potential undefined behaviour. */
 	interner:       Interner<UniStr<'a>, SymbolId>,
 	files:          Vec<Arc<FileData>>,
-	deps:           DepMap,
 	next_id:        AtomicU32,
-	types:          boxcar::Vec<OryxType>,
 }
 
 impl<'a> CompilerState<'a> {
@@ -164,6 +134,17 @@ impl<'a> CompilerState<'a> {
 		self.wake_all();
 	}
 
+	/// Push multiple jobs onto a worker’s local queue and wake all
+	/// threads.
+	#[inline(always)]
+	pub fn job_push_multi(&self, queue: &Worker<Job>, jobs: &[Job]) {
+		self.njobs.fetch_add(jobs.len(), Ordering::Relaxed);
+		for job in jobs.iter() {
+			queue.push(job.clone());
+		}
+		self.wake_all();
+	}
+
 	/// Signal a job completion by decrementing the job count.
 	///
 	/// Returns the number of remaining jobs
@@ -202,28 +183,12 @@ where
 
 	let state = Arc::new(CompilerState {
 		files,
-		global_arena: GlobalArena::new(size::kibibytes(64)),
 		globalq: Injector::new(),
 		njobs: AtomicUsize::new(njobs),
 		flags,
 		worker_threads: OnceLock::new(),
 		interner: Interner::new(),
-		deps: DepMap::with_capacity(256),
 		next_id: AtomicU32::new(njobs as u32),
-		/* Temporary solution */
-		types: boxcar::vec![
-			OryxType::Integer /* int  */ { bits:  64, signed: true  },
-			OryxType::Integer /* i8   */ { bits:   8, signed: true  },
-			OryxType::Integer /* i16  */ { bits:  16, signed: true  },
-			OryxType::Integer /* i32  */ { bits:  32, signed: true  },
-			OryxType::Integer /* i64  */ { bits:  64, signed: true  },
-			OryxType::Integer /* i128 */ { bits: 128, signed: true  },
-			OryxType::Integer /* u8   */ { bits:   8, signed: false },
-			OryxType::Integer /* u16  */ { bits:  16, signed: false },
-			OryxType::Integer /* u32  */ { bits:  32, signed: false },
-			OryxType::Integer /* u64  */ { bits:  64, signed: false },
-			OryxType::Integer /* u128 */ { bits: 128, signed: false },
-		],
 	});
 
 	for job in initial_jobs {
@@ -248,7 +213,6 @@ where
 		for (i, w) in workers.into_iter().enumerate() {
 			let stealers = Arc::clone(&stealers);
 			let state = Arc::clone(&state);
-			let arena = LocalArena::new(&state.global_arena);
 			let handle = s.spawn(move || worker_loop(i, state, w, stealers));
 			worker_threads[i].write(handle.thread().clone());
 			handles[i].write(handle);
@@ -282,7 +246,6 @@ fn worker_loop(
 	stealers: Arc<[Stealer<Job>]>,
 ) -> bool {
 	let mut ok = true;
-	let arena = LocalArena::new(&c_state.global_arena);
 
 	loop {
 		let Some(job) = find_task(&queue, &c_state.globalq, &stealers) else {
@@ -338,108 +301,19 @@ fn worker_loop(
 					}
 				}
 
-				let root = (ast.nodes.len() - 1) as u32;
 				fdata.ast.set(ast).unwrap();
-				fdata.scopes.set(HTrie::new()).unwrap();
-
-				c_state.job_push(
-					&queue,
-					c_state.job_new(JobType::IndexScopeConstants {
-						fdata,
-						block: root,
-						parent: ScopeId::INVALID,
-					}),
-				);
+				fdata.scopes.set(Vec::new()).unwrap();
+
+				// c_state.job_push(
+				// 	&queue,
+				// 	c_state.job_new(JobType::IndexScopeConstants {
+				// 		fdata,
+				// 		block: root,
+				// 		parent: ScopeId::INVALID,
+				// 	}),
+				// );
 				true
 			},
-
-			JobType::IndexScopeConstants {
-				fdata,
-				block,
-				parent,
-			} => {
-				let tokens = fdata.tokens.get().unwrap();
-				let ast = fdata.ast.get().unwrap();
-				let SubNodes(beg, nstmts) = ast.nodes.sub()[block as usize];
-
-				let mut errors = Vec::new();
-				let scope = Scope::new(parent);
-
-				/* First pass inserts all the symbols in this scope into the
-				 * symbol table */
-				for i in beg..beg + nstmts {
-					let node = ast.extra[i as usize];
-					if ast.nodes.kind()[node as usize] != AstType::MultiDefBind
-					{
-						continue;
-					}
-
-					let identsbeg = ast.nodes.sub()[node as usize].0;
-					let nidents = ast.extra[identsbeg as usize];
-
-					for j in 0..nidents {
-						let ident = ast.extra[(identsbeg + 1 + j * 2) as usize];
-						let span = tokens.view()[ident as usize];
-
-						/* Make string slice lifetime 'static */
-						let view = unsafe {
-							&*(&fdata.buffer[span.0..span.1] as *const str)
-						};
-
-						let symid = c_state.interner.intern(UniStr(view));
-						let sym = Symbol {
-							state: ResolutionState::Unresolved,
-							kind:  SymbolType::Constant,
-						};
-
-						if let Some(mut sym) =
-							scope.symtab.insert(symid, sym, &arena)
-						{
-							sym.state = ResolutionState::Poisoned;
-							scope.symtab.insert(symid, sym, &arena);
-							errors.push(OryxError::new(
-								span,
-								format!(
-									"symbol ‘{view}’ defined multiple times"
-								),
-							));
-						}
-					}
-				}
-
-				let scopeid = if parent == ScopeId::INVALID {
-					ScopeId::GLOBAL
-				} else {
-					ScopeId(c_state.genid())
-				};
-				fdata.scopes.get().unwrap().insert(scopeid, scope, &arena);
-
-				/* Second pass emits jobs to resolve types */
-				for i in beg..beg + nstmts {
-					let node = ast.extra[i as usize];
-					if ast.nodes.kind()[node as usize] != AstType::MultiDefBind
-					{
-						continue;
-					}
-					c_state.job_push(
-						&queue,
-						c_state.job_new(JobType::ResolveDefBind {
-							fdata: fdata.clone(),
-							node,
-							scope: scopeid,
-						}),
-					);
-				}
-
-				let ok = errors.is_empty();
-				emit_errors(&fdata, errors);
-				ok
-			},
-
-            JobType::ResolveDefBind { fdata, node, scope } => {
-                todo!("resolving is yet to be implemented");
-                true
-            },
 		};
 		if !result {
 			ok = false;
diff --git a/oryxc/src/depmap.rs b/oryxc/src/depmap.rs
deleted file mode 100644
index 60e358e..0000000
--- a/oryxc/src/depmap.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use boxcar;
-use dashmap::DashMap;
-
-use crate::compiler::Job;
-use crate::prelude::*;
-
-pub struct DepMap(DashMap<Dependency, boxcar::Vec<Job>>);
-
-#[derive(Eq, Hash, PartialEq)]
-pub enum Dependency {
-	Symbol(SymbolId),
-}
-
-impl DepMap {
-	pub fn with_capacity(n: usize) -> Self {
-		return Self(DashMap::with_capacity(n));
-	}
-
-	pub fn add(&self, d: Dependency, j: Job) {
-		self.0
-			.entry(d)
-			.and_modify(|v| {
-				v.push(j.clone());
-			})
-			.or_insert_with(|| boxcar::vec![j]);
-	}
-
-	pub fn pop(&self, d: Dependency) -> Option<boxcar::Vec<Job>> {
-		return self.0.remove(&d).map(|(_, v)| v);
-	}
-}
diff --git a/oryxc/src/hashtrie.rs b/oryxc/src/hashtrie.rs
deleted file mode 100644
index 87c561e..0000000
--- a/oryxc/src/hashtrie.rs
+++ /dev/null
@@ -1,219 +0,0 @@
-use std::hash::{
-	Hash,
-	Hasher,
-};
-use std::ptr;
-use std::sync::atomic::{
-	AtomicPtr,
-	Ordering,
-};
-
-use crate::arena::LocalArena;
-
-struct FNV1a {
-	state: u64,
-}
-
-impl FNV1a {
-	const OFFSET_BASIS: u64 = 0xCBF29CE484222325;
-	const PRIME: u64 = 0x00000100000001B3;
-
-	fn new() -> Self {
-		return Self {
-			state: Self::OFFSET_BASIS,
-		};
-	}
-}
-
-impl Hasher for FNV1a {
-	fn write(&mut self, bytes: &[u8]) {
-		for &b in bytes {
-			self.state ^= b as u64;
-			self.state = self.state.wrapping_mul(Self::PRIME);
-		}
-	}
-
-	fn finish(&self) -> u64 {
-		return self.state;
-	}
-}
-
-pub struct HTrieNode<K, V>
-where
-	K: Copy + Eq + Hash,
-{
-	sub: [AtomicPtr<HTrieNode<K, V>>; 4],
-	key: K,
-	val: AtomicPtr<V>,
-}
-
-impl<K, V> HTrieNode<K, V>
-where
-	K: Copy + Eq + Hash,
-{
-	fn new(key: K, valptr: *mut V) -> Self {
-		return Self {
-			sub: [
-				AtomicPtr::new(ptr::null_mut()),
-				AtomicPtr::new(ptr::null_mut()),
-				AtomicPtr::new(ptr::null_mut()),
-				AtomicPtr::new(ptr::null_mut()),
-			],
-			key,
-			val: AtomicPtr::new(valptr),
-		};
-	}
-}
-
-#[derive(Debug)]
-pub struct HTrie<K, V>
-where
-	K: Copy + Eq + Hash,
-{
-	root: AtomicPtr<HTrieNode<K, V>>,
-}
-
-impl<K, V> HTrie<K, V>
-where
-	K: Copy + Eq + Hash,
-{
-	pub fn new() -> Self {
-		return Self {
-			root: AtomicPtr::new(ptr::null_mut()),
-		};
-	}
-
-	/// Lock-free insert into the hash-trie.
-	///
-	/// Returns `None` if the key was newly inserted.
-	/// Returns `Some(val)` with the previous value if the key already
-	/// existed.
-	pub fn insert(&self, key: K, val: V, arena: &LocalArena) -> Option<V> {
-		let mut h = {
-			let mut h = FNV1a::new();
-			key.hash(&mut h);
-			h.finish()
-		};
-
-		let mut m = &self.root;
-		let valptr = arena.alloc(val);
-
-		loop {
-			let mut n = m.load(Ordering::Acquire);
-
-			if n.is_null() {
-				let mark = arena.mark();
-				let node = arena.alloc(HTrieNode::new(key, valptr));
-
-				match m.compare_exchange(
-					ptr::null_mut(),
-					node as *mut HTrieNode<K, V>,
-					Ordering::Release,
-					Ordering::Acquire,
-				) {
-					Ok(_) => {
-						return None;
-					},
-					Err(ptr) => {
-						arena.restore(mark);
-						n = ptr;
-					},
-				}
-			}
-
-			let n = unsafe { &*n };
-
-			if n.key == key {
-				let old_valptr = n.val.swap(valptr, Ordering::AcqRel);
-
-				if old_valptr.is_null() {
-					return None;
-				} else {
-					let old_val = unsafe { ptr::read(old_valptr) };
-					return Some(old_val);
-				}
-			}
-
-			m = &n.sub[(h >> 62) as usize];
-			h <<= 2;
-		}
-	}
-
-	/// Check if the given key exists in the hash-trie.
-	pub fn contains(&self, key: K) -> bool {
-		let mut h = {
-			let mut h = FNV1a::new();
-			key.hash(&mut h);
-			h.finish()
-		};
-
-		let mut m = &self.root;
-
-		loop {
-			let n = m.load(Ordering::Acquire);
-			if n.is_null() {
-				return false;
-			}
-			let n = unsafe { &*n };
-			if n.key == key {
-				return !n.val.load(Ordering::Acquire).is_null();
-			}
-			m = &n.sub[(h >> 62) as usize];
-			h <<= 2;
-		}
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use crate::arena::{
-		GlobalArena,
-		LocalArena,
-	};
-	use crate::hashtrie::HTrie;
-
-	#[test]
-	fn test_htrie_insert() {
-		let ga = GlobalArena::new(128);
-		let la = LocalArena::new(&ga);
-		let ht = HTrie::new();
-
-		assert_eq!(ht.insert("foo", "bar", &la), None);
-		assert_eq!(ht.insert("hello", "sailor", &la), None);
-		assert_eq!(ht.insert("thomas", "voss", &la), None);
-	}
-
-	#[test]
-	fn test_htrie_overwrite() {
-		let ga = GlobalArena::new(128);
-		let la = LocalArena::new(&ga);
-		let ht = HTrie::new();
-
-		ht.insert("foo", "bar", &la);
-		ht.insert("hello", "sailor", &la);
-		ht.insert("thomas", "voss", &la);
-		assert_eq!(ht.insert("foo", "bar-0", &la), Some("bar"));
-		assert_eq!(ht.insert("hello", "sailor-0", &la), Some("sailor"));
-		assert_eq!(ht.insert("thomas", "voss-0", &la), Some("voss"));
-		assert_eq!(ht.insert("foo", "bar-1", &la), Some("bar-0"));
-		assert_eq!(ht.insert("hello", "sailor-1", &la), Some("sailor-0"));
-		assert_eq!(ht.insert("thomas", "voss-1", &la), Some("voss-0"));
-	}
-
-	#[test]
-	fn test_htrie_contains() {
-		let ga = GlobalArena::new(128);
-		let la = LocalArena::new(&ga);
-		let ht = HTrie::new();
-
-		assert!(!ht.contains("foo"));
-		assert!(!ht.contains("hello"));
-		assert!(!ht.contains("thomas"));
-		ht.insert("foo", "bar", &la);
-		ht.insert("hello", "sailor", &la);
-		ht.insert("thomas", "voss", &la);
-		assert!(ht.contains("foo"));
-		assert!(ht.contains("hello"));
-		assert!(ht.contains("thomas"));
-	}
-}
diff --git a/oryxc/src/main.rs b/oryxc/src/main.rs
index a5cd0a8..8d38ab1 100644
--- a/oryxc/src/main.rs
+++ b/oryxc/src/main.rs
@@ -1,10 +1,7 @@
 #![allow(unsafe_op_in_unsafe_fn)]
 
-mod arena;
 mod compiler;
-mod depmap;
 mod errors;
-mod hashtrie;
 mod intern;
 mod lexer;
 mod parser;
diff --git a/oryxc/src/parser.rs b/oryxc/src/parser.rs
index 629b290..8c24df1 100644
--- a/oryxc/src/parser.rs
+++ b/oryxc/src/parser.rs
@@ -46,8 +46,10 @@ pub struct AstNode {
 
 #[derive(Debug)]
 pub struct Ast {
-	pub nodes: Soa<AstNode>,
-	pub extra: Vec<u32>,
+	pub nodes:  Soa<AstNode>,
+	pub extra:  Vec<u32>,
+	pub types:  Box<[TypeId]>,
+	pub textra: boxcar::Vec<TypeId>,
 }
 
 struct Parser<'a> {
@@ -917,8 +919,12 @@ pub fn parse(tokens: &Soa<Token>) -> Result<Ast, Vec<OryxError>> {
 		tok:  0,
 		sub:  SubNodes(stmtsbeg as u32, nstmts as u32),
 	});
+	let nodecnt = p.ast.len();
 	return Ok(Ast {
-		nodes: p.ast,
-		extra: p.extra_data,
+		nodes:  p.ast,
+		extra:  p.extra_data,
+		types:  vec![TypeId::INVALID; nodecnt].into_boxed_slice(),
+		/* TODO: Get the parser to try to compute the required capacity */
+		textra: boxcar::vec![],
 	});
 }
diff --git a/oryxc/src/prelude.rs b/oryxc/src/prelude.rs
index 0d1fc15..5628c87 100644
--- a/oryxc/src/prelude.rs
+++ b/oryxc/src/prelude.rs
@@ -1,11 +1,10 @@
+use std::collections::HashMap;
 use std::fmt::{
 	self,
 	Debug,
 	Formatter,
 };
 
-use crate::hashtrie::HTrie;
-
 macro_rules! mkidtype {
 	($name:ident) => {
 		#[repr(transparent)]
@@ -38,17 +37,33 @@ impl ScopeId {
 	pub const GLOBAL: Self = Self(0);
 }
 
+impl TypeId {
+	const MVMSK: u32 = 1 << 31;
+
+	pub fn to_mvindex(&self) -> Option<usize> {
+		return if self.0 & Self::MVMSK != 0 {
+			Some((self.0 & !Self::MVMSK) as usize)
+		} else {
+			None
+		};
+	}
+
+	pub fn from_mvindex(i: usize) -> Self {
+		return Self(i as u32 & Self::MVMSK);
+	}
+}
+
 #[derive(Debug)]
 pub struct Scope {
 	pub parent: ScopeId,
-	pub symtab: HTrie<SymbolId, Symbol>,
+	pub symtab: HashMap<SymbolId, Symbol>,
 }
 
 impl Scope {
 	pub fn new(parent: ScopeId) -> Self {
 		return Self {
 			parent,
-			symtab: HTrie::new(),
+			symtab: HashMap::new(),
 		};
 	}
 }
@@ -77,10 +92,19 @@ pub enum SymbolType {
 }
 
 pub enum OryxType {
-	Integer { bits: usize, signed: bool },
 	Boolean,
-	Pointer { base: u32 },
-	Function { args: Vec<u32>, rets: Vec<u32> },
+	Function {
+		args: Box<[TypeId]>,
+		rets: Box<[TypeId]>,
+	},
+	Integer {
+		bits:   usize,
+		signed: bool,
+	},
+	Pointer {
+		base: u32,
+	},
+	Type(TypeId),
 }
 
 #[derive(Clone, Copy)]
diff --git a/oryxc/src/unistr.rs b/oryxc/src/unistr.rs
index 158fed1..f9ea3d0 100644
--- a/oryxc/src/unistr.rs
+++ b/oryxc/src/unistr.rs
@@ -45,10 +45,10 @@ impl PartialEq for UniStr<'_> {
 			unicode_normalization::is_nfkd_quick(other.0.chars())
 				== IsNormalized::Yes,
 		) {
-			(true, true) => self.0 == other.0,
-			(true, false) => self.0.chars() == other.0.nfkd(),
-			(false, true) => self.0.nfkd() == other.0.chars(),
-			(false, false) => self.0.nfkd() == other.0.nfkd(),
+			(true, true) => self.0.eq(other.0),
+			(true, false) => self.0.chars().eq(other.0.nfkd()),
+			(false, true) => self.0.nfkd().eq(other.0.chars()),
+			(false, false) => self.0.nfkd().eq(other.0.nfkd()),
 		};
 	}
 }