task_local context over context objects

- interner impls logically separate from API in orchid-base (default host interner still in base for testing)
- error reporting, logging, and a variety of other features passed down via context in extension, not yet in host to maintain library-ish profile, should consider options
- no global spawn mechanic, the host has a spawn function but extensions only get a stash for enqueuing async work in sync callbacks which is then explicitly, manually, and with strict order popped and awaited
- still deadlocks nondeterministically for some ungodly reason

orchid-host/src/sys_parser.rs

@@ -2,11 +2,11 @@ use futures::FutureExt;
 use futures::future::join_all;
 use itertools::Itertools;
 use orchid_base::error::{OrcErrv, OrcRes};
-use orchid_base::interner::{Interner, Tok};
+use orchid_base::interner::{IStr, es};
 use orchid_base::location::SrcRange;
 use orchid_base::name::Sym;
 use orchid_base::parse::Comment;
-use orchid_base::reqnot::Requester;
+use orchid_base::reqnot::ClientExt;
 use orchid_base::tree::ttv_from_api;
 use substack::Substack;
 
@@ -22,7 +22,7 @@ pub struct Parser {
 	pub(crate) system: System,
 	pub(crate) idx: u16,
 }
-type ModPath<'a> = Substack<'a, Tok<String>>;
+type ModPath<'a> = Substack<'a, IStr>;
 
 impl Parser {
 	pub async fn parse(
@@ -39,7 +39,7 @@ impl Parser {
 		let line =
 			join_all((line.into_iter()).map(|t| async { tt_to_api(&mut temp_store.clone(), t).await }))
 				.await;
-		let mod_path = ctx.src_path().suffix(path.unreverse(), self.system.i()).await;
+		let mod_path = ctx.src_path().suffix(path.unreverse()).await;
 		let comments = comments.iter().map(Comment::to_api).collect_vec();
 		let req = api::ParseLine {
 			idx: self.idx,
@@ -50,17 +50,16 @@ impl Parser {
 			comments,
 			line,
 		};
-		match self.system.reqnot().request(req).await {
+		match self.system.client().request(req).await.unwrap() {
 			Ok(parsed_v) =>
 				conv(parsed_v, path, callback, &mut ConvCtx {
-					i: self.system.i(),
 					mod_path: &mod_path,
 					ext_exprs: &mut temp_store,
 					src_path: &src_path,
 					sys: &self.system,
 				})
 				.await,
-			Err(e) => Err(OrcErrv::from_api(&e, &self.system.ctx().i).await),
+			Err(e) => Err(OrcErrv::from_api(&e).await),
 		}
 	}
 }
@@ -69,13 +68,12 @@ struct ConvCtx<'a> {
 	sys: &'a System,
 	mod_path: &'a Sym,
 	src_path: &'a Sym,
-	i: &'a Interner,
 	ext_exprs: &'a mut ExprStore,
 }
 async fn conv(
 	parsed_v: Vec<api::ParsedLine>,
-	module: Substack<'_, Tok<String>>,
-	callback: &'_ mut impl AsyncFnMut(Substack<'_, Tok<String>>, Vec<ParsTokTree>) -> OrcRes<Vec<Item>>,
+	module: Substack<'_, IStr>,
+	callback: &'_ mut impl AsyncFnMut(Substack<'_, IStr>, Vec<ParsTokTree>) -> OrcRes<Vec<Item>>,
 	ctx: &mut ConvCtx<'_>,
 ) -> OrcRes<Vec<Item>> {
 	let mut items = Vec::new();
@@ -85,12 +83,12 @@ async fn conv(
 				(name, exported, kind),
 			api::ParsedLineKind::Recursive(rec) => {
 				let tokens =
-					ttv_from_api(rec, ctx.ext_exprs, &mut ctx.sys.ctx().clone(), ctx.src_path, ctx.i).await;
+					ttv_from_api(rec, ctx.ext_exprs, &mut ctx.sys.ctx().clone(), ctx.src_path).await;
 				items.extend(callback(module.clone(), tokens).await?);
 				continue;
 			},
 		};
-		let name = ctx.i.ex(name).await;
+		let name = es(name).await;
 		let mem_path = module.push(name.clone());
 		let mkind = match kind {
 			api::ParsedMemberKind::Module { lines, use_prelude } => {
@@ -98,16 +96,16 @@ async fn conv(
 				ParsedMemberKind::Mod(ParsedModule::new(use_prelude, items))
 			},
 			api::ParsedMemberKind::Constant(cid) => {
-				ctx.sys.0.const_paths.insert(cid, ctx.mod_path.suffix(mem_path.unreverse(), ctx.i).await);
+				ctx.sys.0.const_paths.insert(cid, ctx.mod_path.suffix(mem_path.unreverse()).await);
 				ParsedMemberKind::Const(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)),
+				parsed.comments.iter().map(|c| Comment::from_api(c, ctx.src_path.clone())),
 			)
 			.await,
-			sr: SrcRange::from_api(&parsed.source_range, ctx.i).await,
+			sr: SrcRange::from_api(&parsed.source_range).await,
 			kind: ItemKind::Member(ParsedMember { name, exported, kind: mkind }),
 		})
 	}