exec working up to halt

clean shutdown doesn't for some reason

orchid-host/src/system.rs

@@ -3,38 +3,32 @@ use std::fmt;
 use std::future::Future;
 use std::rc::{Rc, Weak};
 
+use async_lock::RwLock;
 use derive_destructure::destructure;
-use futures::FutureExt;
 use futures::future::join_all;
 use hashbrown::HashMap;
 use itertools::Itertools;
 use memo_map::MemoMap;
 use orchid_base::char_filter::char_filter_match;
-use orchid_base::error::{OrcErrv, OrcRes, mk_errv_floating};
+use orchid_base::error::{OrcRes, mk_errv_floating};
 use orchid_base::format::{FmtCtx, FmtUnit, Format};
 use orchid_base::interner::{Interner, Tok};
 use orchid_base::iter_utils::IteratorPrint;
-use orchid_base::location::SrcRange;
 use orchid_base::name::{NameLike, Sym, VName, VPath};
-use orchid_base::parse::Comment;
 use orchid_base::reqnot::{ReqNot, Requester};
-use orchid_base::tree::{recur, ttv_from_api};
 use ordered_float::NotNan;
 use substack::{Stackframe, Substack};
 
 use crate::api;
+use crate::atom::{AtomHand, WeakAtomHand};
 use crate::ctx::Ctx;
 use crate::dealias::walk;
-use crate::expr::{ExprParseCtx, ExprWillPanic};
-use crate::expr_store::ExprStore;
 use crate::extension::{Extension, WeakExtension};
-use crate::parsed::{
-	Item, ItemKind, ParsTok, ParsTokTree, ParsedMember, ParsedMemberKind, ParsedModule,
-};
+use crate::sys_parser::Parser;
 use crate::tree::Root;
 
 #[derive(destructure)]
-struct SystemInstData {
+pub(crate) struct SystemInstData {
 	deps: Vec<System>,
 	ctx: Ctx,
 	ext: Extension,
@@ -43,6 +37,7 @@ struct SystemInstData {
 	id: api::SysId,
 	line_types: Vec<Tok<String>>,
 	prelude: Vec<Sym>,
+	owned_atoms: RwLock<HashMap<api::AtomId, WeakAtomHand>>,
 	pub(crate) const_paths: MemoMap<api::ParsedConstId, Sym>,
 }
 impl Drop for SystemInstData {
@@ -60,7 +55,7 @@ impl fmt::Debug for SystemInstData {
 }
 
 #[derive(Clone, Debug)]
-pub struct System(Rc<SystemInstData>);
+pub struct System(pub(crate) Rc<SystemInstData>);
 impl System {
 	#[must_use]
 	pub fn id(&self) -> api::SysId { self.0.id }
@@ -101,108 +96,32 @@ impl System {
 		self.0.ext.lex_req(source, src, pos, self.id(), r).await
 	}
 	#[must_use]
-	pub fn can_parse(&self, ltyp: Tok<String>) -> bool { self.0.line_types.contains(&ltyp) }
-	pub fn line_types(&self) -> impl Iterator<Item = &Tok<String>> + '_ { self.0.line_types.iter() }
-	pub async fn parse(
-		&self,
-		path: Substack<'_, Tok<String>>,
-		line: Vec<ParsTokTree>,
-		exported: bool,
-		comments: Vec<Comment>,
-		callback: &mut impl AsyncFnMut(Substack<'_, Tok<String>>, Vec<ParsTokTree>) -> OrcRes<Vec<Item>>,
-	) -> OrcRes<Vec<Item>> {
-		let src_path = line.first().expect("cannot be empty").sr.path();
-		let line = join_all(line.into_iter().map(|t| async {
-			let mut expr_store = self.0.ext.exprs().clone();
-			let without_new_expr = recur(t, &|t, r| {
-				if let ParsTok::NewExpr(expr) = t.tok {
-					return ParsTok::Handle(expr).at(t.sr);
-				}
-				r(t)
-			});
-			without_new_expr.into_api(&mut expr_store, &mut ExprWillPanic).await
-		}))
-		.await;
-		let comments = comments.iter().map(Comment::to_api).collect_vec();
-		let req = api::ParseLine {
-			module: self.i().i(&path.unreverse()).await.to_api(),
-			src: src_path.to_api(),
-			exported,
-			sys: self.id(),
-			comments,
-			line,
-		};
-		match self.reqnot().request(req).await {
-			Ok(parsed_v) => {
-				let mut ext_exprs = self.ext().exprs().clone();
-				struct ConvCtx<'a> {
-					sys: &'a System,
-					src_path: &'a Sym,
-					i: &'a Interner,
-					ext_exprs: &'a mut ExprStore,
-					pctx: &'a mut ExprParseCtx<'a>,
-				}
-				async fn conv(
-					parsed_v: Vec<api::ParsedLine>,
-					module: Substack<'_, Tok<String>>,
-					callback: &'_ mut impl AsyncFnMut(
-						Substack<'_, Tok<String>>,
-						Vec<ParsTokTree>,
-					) -> OrcRes<Vec<Item>>,
-					ctx: &mut ConvCtx<'_>,
-				) -> OrcRes<Vec<Item>> {
-					let mut items = Vec::new();
-					for parsed in parsed_v {
-						let (name, exported, kind) = match parsed.kind {
-							api::ParsedLineKind::Member(api::ParsedMember { name, exported, kind }) =>
-								(name, exported, kind),
-							api::ParsedLineKind::Recursive(rec) => {
-								let tokens = ttv_from_api(rec, ctx.ext_exprs, ctx.pctx, ctx.src_path, ctx.i).await;
-								items.extend(callback(module.clone(), tokens).await?);
-								continue;
-							},
-						};
-						let name = ctx.i.ex(name).await;
-						let mkind = match kind {
-							api::ParsedMemberKind::Module { lines, use_prelude } => {
-								let items =
-									conv(lines, module.push(name.clone()), callback, ctx).boxed_local().await?;
-								ParsedMemberKind::Mod(ParsedModule::new(use_prelude, items))
-							},
-							api::ParsedMemberKind::Constant(cid) =>
-								ParsedMemberKind::DeferredConst(cid, ctx.sys.clone()),
-						};
-						items.push(Item {
-							comments: join_all(
-								parsed.comments.iter().map(|c| Comment::from_api(c, ctx.src_path.clone(), ctx.i)),
-							)
-							.await,
-							sr: SrcRange::from_api(&parsed.source_range, ctx.i).await,
-							kind: ItemKind::Member(ParsedMember { name, exported, kind: mkind }),
-						})
-					}
-					Ok(items)
-				}
-				conv(parsed_v, path, callback, &mut ConvCtx {
-					i: self.i(),
-					ext_exprs: &mut ext_exprs,
-					pctx: &mut ExprParseCtx { ctx: self.ctx(), exprs: self.ext().exprs() },
-					src_path: &src_path,
-					sys: self,
-				})
-				.await
-			},
-			Err(e) => Err(OrcErrv::from_api(&e, &self.ctx().i).await),
-		}
+	pub fn get_parser(&self, ltyp: Tok<String>) -> Option<Parser> {
+		(self.0.line_types.iter().enumerate())
+			.find(|(_, txt)| *txt == &ltyp)
+			.map(|(idx, _)| Parser { idx: idx as u16, system: self.clone() })
 	}
+	pub fn line_types(&self) -> impl Iterator<Item = &Tok<String>> + '_ { self.0.line_types.iter() }
+
 	#[must_use]
 	pub async fn request(&self, req: Vec<u8>) -> Vec<u8> {
 		self.reqnot().request(api::SysFwded(self.id(), req)).await
 	}
+	pub(crate) async fn new_atom(&self, data: Vec<u8>, id: api::AtomId) -> AtomHand {
+		let mut owned_g = self.0.owned_atoms.write().await;
+		if let Some(data) = owned_g.get(&id)
+			&& let Some(atom) = data.upgrade()
+		{
+			return atom;
+		}
+		let new = AtomHand::new(data, self.clone(), Some(id));
+		owned_g.insert(id, new.downgrade());
+		new
+	}
 	pub(crate) fn drop_atom(&self, drop: api::AtomId) {
 		let this = self.0.clone();
 		(self.0.ctx.spawn)(Box::pin(async move {
-			this.ctx.owned_atoms.write().await.remove(&drop);
+			this.owned_atoms.write().await.remove(&drop);
 		}))
 	}
 	#[must_use]
@@ -218,7 +137,7 @@ impl System {
 		async move |rel| {
 			let cwd = orig.split_last_seg().1;
 			let root_data = &mut *root.0.write().await;
-			let walk_ctx = &mut (ctx.clone(), &mut root_data.consts);
+			let walk_ctx = &mut (ctx.clone(), &root_data.consts);
 			let cmod = (walk(&root_data.root, false, cwd.iter().cloned(), walk_ctx).await)
 				.expect("the parent module of a constant should exist");
 			let (selector, tail) = rel.split_first().expect("Names cannot be empty");
@@ -298,6 +217,7 @@ impl SystemCtor {
 				.await,
 			id,
 			prelude: join_all(sys_inst.prelude.iter().map(|tok| Sym::from_api(*tok, &ext.ctx().i))).await,
+			owned_atoms: RwLock::new(HashMap::new()),
 			const_paths: MemoMap::new(),
 		}));
 		let api_module_root = api::Module {