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/system.rs

@@ -1,4 +1,5 @@
 use std::any::{Any, TypeId};
+use std::fmt::Debug;
 use std::future::Future;
 use std::num::NonZero;
 use std::pin::Pin;
@@ -8,13 +9,13 @@ use futures::future::LocalBoxFuture;
 use orchid_api_traits::{Coding, Decode, Encode, Request};
 use orchid_base::boxed_iter::BoxedIter;
 use orchid_base::name::Sym;
-use orchid_base::reqnot::{Receipt, Requester};
+use orchid_base::reqnot::{Receipt, ReqHandle, ReqReader, ReqReaderExt};
+use task_local::task_local;
 
 use crate::api;
 use crate::atom::{AtomCtx, AtomDynfo, AtomTypeId, AtomicFeatures, ForeignAtom, TAtom, get_info};
-use crate::context::ctx;
 use crate::coroutine_exec::Replier;
-use crate::entrypoint::ExtReq;
+use crate::entrypoint::request;
 use crate::func_atom::{Fun, Lambda};
 use crate::lexer::LexerObj;
 use crate::parser::ParserObj;
@@ -22,7 +23,7 @@ use crate::system_ctor::{CtedObj, SystemCtor};
 use crate::tree::GenMember;
 
 /// System as consumed by foreign code
-pub trait SystemCard: Default + Send + Sync + 'static {
+pub trait SystemCard: Debug + Default + Send + Sync + 'static {
 	type Ctor: SystemCtor;
 	type Req: Coding;
 	fn atoms() -> impl IntoIterator<Item = Option<Box<dyn AtomDynfo>>>;
@@ -67,7 +68,7 @@ pub async fn resolv_atom(
 	sys: &(impl DynSystemCard + ?Sized),
 	atom: &api::Atom,
 ) -> Box<dyn AtomDynfo> {
-	let tid = AtomTypeId::decode(Pin::new(&mut &atom.data.0[..])).await;
+	let tid = AtomTypeId::decode(Pin::new(&mut &atom.data.0[..])).await.unwrap();
 	atom_by_idx(sys, tid).expect("Value of nonexistent type found")
 }
 
@@ -84,7 +85,10 @@ pub trait System: Send + Sync + SystemCard + 'static {
 	fn env() -> impl Future<Output = Vec<GenMember>>;
 	fn lexers() -> Vec<LexerObj>;
 	fn parsers() -> Vec<ParserObj>;
-	fn request(hand: ExtReq<'_>, req: Self::Req) -> impl Future<Output = Receipt<'_>>;
+	fn request<'a>(
+		hand: Box<dyn ReqHandle<'a> + 'a>,
+		req: Self::Req,
+	) -> impl Future<Output = Receipt<'a>>;
 }
 
 pub trait DynSystem: Send + Sync + DynSystemCard + 'static {
@@ -92,7 +96,7 @@ pub trait DynSystem: Send + Sync + DynSystemCard + 'static {
 	fn dyn_env(&self) -> LocalBoxFuture<'_, Vec<GenMember>>;
 	fn dyn_lexers(&self) -> Vec<LexerObj>;
 	fn dyn_parsers(&self) -> Vec<ParserObj>;
-	fn dyn_request<'a>(&self, hand: ExtReq<'a>, req: Vec<u8>) -> LocalBoxFuture<'a, Receipt<'a>>;
+	fn dyn_request<'a>(&self, hand: Box<dyn ReqReader<'a> + 'a>) -> LocalBoxFuture<'a, Receipt<'a>>;
 	fn card(&self) -> &dyn DynSystemCard;
 }
 
@@ -101,26 +105,41 @@ impl<T: System> DynSystem for T {
 	fn dyn_env(&self) -> LocalBoxFuture<'_, Vec<GenMember>> { Self::env().boxed_local() }
 	fn dyn_lexers(&self) -> Vec<LexerObj> { Self::lexers() }
 	fn dyn_parsers(&self) -> Vec<ParserObj> { Self::parsers() }
-	fn dyn_request<'a>(&self, hand: ExtReq<'a>, req: Vec<u8>) -> LocalBoxFuture<'a, Receipt<'a>> {
+	fn dyn_request<'a>(
+		&self,
+		mut hand: Box<dyn ReqReader<'a> + 'a>,
+	) -> LocalBoxFuture<'a, Receipt<'a>> {
 		Box::pin(async move {
-			Self::request(hand, <Self as SystemCard>::Req::decode(Pin::new(&mut &req[..])).await).await
+			let value = hand.read_req::<<Self as SystemCard>::Req>().await.unwrap();
+			Self::request(hand.finish().await, value).await
 		})
 	}
 	fn card(&self) -> &dyn DynSystemCard { self }
 }
 
+#[derive(Clone)]
+pub(crate) struct SysCtx(pub api::SysId, pub CtedObj);
+
+task_local! {
+	static SYS_CTX: SysCtx;
+}
+
+pub(crate) async fn with_sys<F: Future>(sys: SysCtx, fut: F) -> F::Output {
+	SYS_CTX.scope(sys, fut).await
+}
+
+pub fn sys_id() -> api::SysId { SYS_CTX.with(|cx| cx.0) }
+pub fn cted() -> CtedObj { SYS_CTX.with(|cx| cx.1.clone()) }
 pub async fn downcast_atom<A>(foreign: ForeignAtom) -> Result<TAtom<A>, ForeignAtom>
 where A: AtomicFeatures {
 	let mut data = &foreign.atom.data.0[..];
-	let ctx = ctx();
-	let value = AtomTypeId::decode(Pin::new(&mut data)).await;
-	let own_inst = ctx.get::<CtedObj>().inst();
-	let owner = if *ctx.get::<api::SysId>() == foreign.atom.owner {
+	let value = AtomTypeId::decode_slice(&mut data);
+	let cted = cted();
+	let own_inst = cted.inst();
+	let owner = if sys_id() == foreign.atom.owner {
 		own_inst.card()
 	} else {
-		(ctx.get::<CtedObj>().deps().find(|s| s.id() == foreign.atom.owner))
-			.ok_or_else(|| foreign.clone())?
-			.get_card()
+		cted.deps().find(|s| s.id() == foreign.atom.owner).ok_or_else(|| foreign.clone())?.get_card()
 	};
 	if owner.atoms().flatten().all(|dynfo| dynfo.tid() != TypeId::of::<A>()) {
 		return Err(foreign);
@@ -130,22 +149,24 @@ where A: AtomicFeatures {
 		return Err(foreign);
 	}
 	let val = dynfo.decode(AtomCtx(data, foreign.atom.drop)).await;
-	let value = *val.downcast::<A::Data>().expect("atom decode returned wrong type");
-	Ok(TAtom { value, untyped: foreign })
+	let Ok(value) = val.downcast::<A::Data>() else {
+		panic!("decode of {} returned wrong type.", dynfo.name());
+	};
+	Ok(TAtom { value: *value, untyped: foreign })
 }
 
 pub async fn dep_req<Sys: SystemCard, Req: Request + Into<Sys::Req>>(req: Req) -> Req::Response {
-	let ctx = ctx();
 	let mut msg = Vec::new();
-	req.into().encode(std::pin::pin!(&mut msg)).await;
-	let own_inst = ctx.get::<CtedObj>().inst();
+	req.into().encode_vec(&mut msg);
+	let cted = cted();
+	let own_inst = cted.inst();
 	let owner = if own_inst.card().type_id() == TypeId::of::<Sys>() {
-		ctx.sys_id()
+		sys_id()
 	} else {
-		(ctx.get::<CtedObj>().deps().find(|s| s.get_card().type_id() == TypeId::of::<Sys>()))
+		(cted.deps().find(|s| s.get_card().type_id() == TypeId::of::<Sys>()))
 			.expect("System not in dependency array")
 			.id()
 	};
-	let reply = ctx.reqnot().request(api::SysFwd(owner, msg)).await;
-	Req::Response::decode(std::pin::pin!(&reply[..])).await
+	let reply = request(api::SysFwd(owner, msg)).await;
+	Req::Response::decode(std::pin::pin!(&reply[..])).await.unwrap()
 }