1 files changed, 25 insertions, 151 deletions

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;