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-extension/src/tree.rs

@@ -1,4 +1,6 @@
+use std::cell::RefCell;
 use std::num::NonZero;
+use std::rc::Rc;
 
 use async_fn_stream::stream;
 use dyn_clone::{DynClone, clone_box};
@@ -6,17 +8,16 @@ use futures::future::{LocalBoxFuture, join_all};
 use futures::{FutureExt, StreamExt};
 use hashbrown::HashMap;
 use itertools::Itertools;
-use orchid_base::interner::{Interner, Tok};
+use orchid_base::interner::{IStr, is};
 use orchid_base::location::SrcRange;
 use orchid_base::name::Sym;
 use orchid_base::tree::{TokTree, Token, TokenVariant};
 use substack::Substack;
+use task_local::task_local;
 use trait_set::trait_set;
 
 use crate::api;
-use crate::context::i;
 use crate::conv::ToExpr;
-use crate::entrypoint::MemberRecord;
 use crate::expr::{BorrowedExprStore, Expr, ExprHandle};
 use crate::func_atom::{ExprFunc, Fun};
 use crate::gen_expr::{GExpr, sym_ref};
@@ -27,12 +28,7 @@ pub type GenTok = Token<Expr, GExpr>;
 impl TokenVariant<api::Expression> for GExpr {
 	type FromApiCtx<'a> = ();
 	type ToApiCtx<'a> = ();
-	async fn from_api(
-		_: &api::Expression,
-		_: &mut Self::FromApiCtx<'_>,
-		_: SrcRange,
-		_: &Interner,
-	) -> Self {
+	async fn from_api(_: &api::Expression, _: &mut Self::FromApiCtx<'_>, _: SrcRange) -> Self {
 		panic!("Received new expression from host")
 	}
 	async fn into_api(self, _: &mut Self::ToApiCtx<'_>) -> api::Expression { self.serialize().await }
@@ -40,12 +36,7 @@ impl TokenVariant<api::Expression> for GExpr {
 
 impl TokenVariant<api::ExprTicket> for Expr {
 	type FromApiCtx<'a> = &'a BorrowedExprStore;
-	async fn from_api(
-		api: &api::ExprTicket,
-		exprs: &mut Self::FromApiCtx<'_>,
-		_: SrcRange,
-		_: &Interner,
-	) -> Self {
+	async fn from_api(api: &api::ExprTicket, exprs: &mut Self::FromApiCtx<'_>, _: SrcRange) -> Self {
 		// SAFETY: receiving trees from sublexers implies borrowing
 		Expr::from_handle(ExprHandle::borrowed(*api, exprs))
 	}
@@ -84,9 +75,8 @@ pub fn root_mod(name: &str, mems: impl IntoIterator<Item = Vec<GenMember>>) -> (
 	(name.to_string(), kind)
 }
 pub fn fun<I, O>(public: bool, name: &str, xf: impl ExprFunc<I, O>) -> Vec<GenMember> {
-	let fac = LazyMemberFactory::new(async move |sym| {
-		MemKind::Const(Fun::new(sym, xf).await.to_gen().await)
-	});
+	let fac =
+		LazyMemberFactory::new(async move |sym| MemKind::Const(Fun::new(sym, xf).await.to_gen().await));
 	vec![GenMember { name: name.to_string(), kind: MemKind::Lazy(fac), public, comments: vec![] }]
 }
 pub fn prefix(path: &str, items: impl IntoIterator<Item = Vec<GenMember>>) -> Vec<GenMember> {
@@ -167,10 +157,10 @@ pub struct GenMember {
 	pub comments: Vec<String>,
 }
 impl GenMember {
-	pub async fn into_api(self, tia_cx: &mut impl TreeIntoApiCtx) -> api::Member {
-		let name = i().i::<String>(&self.name).await;
+	pub(crate) async fn into_api(self, tia_cx: &mut impl TreeIntoApiCtx) -> api::Member {
+		let name = is(&self.name).await;
 		let kind = self.kind.into_api(&mut tia_cx.push_path(name.clone())).await;
-		let comments = join_all(self.comments.iter().map(async |cmt| i().i(cmt).await.to_api())).await;
+		let comments = join_all(self.comments.iter().map(async |cmt| is(cmt).await.to_api())).await;
 		api::Member { kind, name: name.to_api(), comments, exported: self.public }
 	}
 }
@@ -181,9 +171,9 @@ pub enum MemKind {
 	Lazy(LazyMemberFactory),
 }
 impl MemKind {
-	pub async fn into_api(self, ctx: &mut impl TreeIntoApiCtx) -> api::MemberKind {
+	pub(crate) async fn into_api(self, ctx: &mut impl TreeIntoApiCtx) -> api::MemberKind {
 		match self {
-			Self::Lazy(lazy) => api::MemberKind::Lazy(ctx.with_lazy(lazy)),
+			Self::Lazy(lazy) => api::MemberKind::Lazy(add_lazy(ctx, lazy)),
 			Self::Const(c) => api::MemberKind::Const(c.serialize().await),
 			Self::Mod { members } => api::MemberKind::Module(api::Module {
 				members: stream(async |mut cx| {
@@ -199,29 +189,58 @@ impl MemKind {
 	}
 }
 
-pub trait TreeIntoApiCtx {
-	fn with_lazy(&mut self, fac: LazyMemberFactory) -> api::TreeId;
-	fn push_path(&mut self, seg: Tok<String>) -> impl TreeIntoApiCtx;
+pub enum MemberRecord {
+	Gen(Vec<IStr>, LazyMemberFactory),
+	Res,
 }
 
-pub struct TreeIntoApiCtxImpl<'a, 'b> {
-	pub basepath: &'a [Tok<String>],
-	pub path: Substack<'a, Tok<String>>,
-	pub lazy_members: &'b mut HashMap<api::TreeId, MemberRecord>,
+#[derive(Clone, Default)]
+pub(crate) struct LazyMemberStore(Rc<RefCell<HashMap<api::TreeId, MemberRecord>>>);
+
+task_local! {
+	static LAZY_MEMBERS: LazyMemberStore;
 }
 
-impl TreeIntoApiCtx for TreeIntoApiCtxImpl<'_, '_> {
-	fn push_path(&mut self, seg: Tok<String>) -> impl TreeIntoApiCtx {
-		TreeIntoApiCtxImpl {
-			lazy_members: self.lazy_members,
-			basepath: self.basepath,
-			path: self.path.push(seg),
-		}
-	}
-	fn with_lazy(&mut self, fac: LazyMemberFactory) -> api::TreeId {
-		let id = api::TreeId(NonZero::new((self.lazy_members.len() + 2) as u64).unwrap());
-		let path = self.basepath.iter().cloned().chain(self.path.unreverse()).collect_vec();
-		self.lazy_members.insert(id, MemberRecord::Gen(path, fac));
+pub fn with_lazy_member_store<'a>(fut: LocalBoxFuture<'a, ()>) -> LocalBoxFuture<'a, ()> {
+	Box::pin(LAZY_MEMBERS.scope(LazyMemberStore::default(), fut))
+}
+
+fn add_lazy(cx: &impl TreeIntoApiCtx, fac: LazyMemberFactory) -> api::TreeId {
+	LAZY_MEMBERS.with(|lazy_members| {
+		let mut g = lazy_members.0.borrow_mut();
+		let id = api::TreeId(NonZero::new((g.len() + 2) as u64).unwrap());
+		let path = cx.path().collect_vec();
+		g.insert(id, MemberRecord::Gen(path, fac));
 		id
+	})
+}
+
+pub async fn get_lazy(id: api::TreeId) -> (Sym, MemKind) {
+	let (path, cb) =
+		LAZY_MEMBERS.with(|tbl| match tbl.0.borrow_mut().insert(id, MemberRecord::Res) {
+			None => panic!("Tree for ID not found"),
+			Some(MemberRecord::Res) => panic!("This tree has already been transmitted"),
+			Some(MemberRecord::Gen(path, cb)) => (path, cb),
+		});
+	let path = Sym::new(path).await.unwrap();
+	(path.clone(), cb.build(path).await)
+}
+
+pub(crate) trait TreeIntoApiCtx {
+	fn push_path(&mut self, seg: IStr) -> impl TreeIntoApiCtx;
+	fn path(&self) -> impl Iterator<Item = IStr>;
+}
+
+pub struct TreeIntoApiCtxImpl<'a> {
+	pub basepath: &'a [IStr],
+	pub path: Substack<'a, IStr>,
+}
+
+impl TreeIntoApiCtx for TreeIntoApiCtxImpl<'_> {
+	fn push_path(&mut self, seg: IStr) -> impl TreeIntoApiCtx {
+		TreeIntoApiCtxImpl { basepath: self.basepath, path: self.path.push(seg) }
+	}
+	fn path(&self) -> impl Iterator<Item = IStr> {
+		self.basepath.iter().cloned().chain(self.path.unreverse())
 	}
 }