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

@@ -14,20 +14,20 @@ use orchid_api_derive::Coding;
 use orchid_api_traits::{Coding, Decode, Encode, Request, enc_vec};
 use orchid_base::error::{OrcErrv, OrcRes, mk_errv, mk_errv_floating};
 use orchid_base::format::{FmtCtx, FmtUnit, Format, fmt};
+use orchid_base::interner::is;
 use orchid_base::location::Pos;
 use orchid_base::name::Sym;
-use orchid_base::reqnot::Requester;
 use trait_set::trait_set;
 
 use crate::api;
-use crate::context::{ctx, i};
 use crate::conv::ToExpr;
+use crate::entrypoint::request;
 // use crate::error::{ProjectError, ProjectResult};
 use crate::expr::{Expr, ExprData, ExprHandle, ExprKind};
 use crate::gen_expr::GExpr;
-use crate::system::{DynSystemCard, atom_info_for, downcast_atom};
+use crate::system::{DynSystemCard, atom_by_idx, atom_info_for, cted, downcast_atom};
 
-#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Coding)]
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Coding)]
 pub struct AtomTypeId(pub NonZeroU32);
 
 pub trait AtomCard: 'static + Sized {
@@ -99,13 +99,13 @@ impl ForeignAtom {
 		ForeignAtom { atom, expr: handle, pos }
 	}
 	pub async fn request<M: AtomMethod>(&self, m: M) -> Option<M::Response> {
-		let rep = (ctx().reqnot().request(api::Fwd(
+		let rep = (request(api::Fwd(
 			self.atom.clone(),
-			Sym::parse(M::NAME, &i()).await.unwrap().tok().to_api(),
-			enc_vec(&m).await,
+			Sym::parse(M::NAME).await.unwrap().tok().to_api(),
+			enc_vec(&m),
 		)))
 		.await?;
-		Some(M::Response::decode(Pin::new(&mut &rep[..])).await)
+		Some(M::Response::decode_slice(&mut &rep[..]))
 	}
 	pub async fn downcast<T: AtomicFeatures>(self) -> Result<TAtom<T>, NotTypAtom> {
 		TAtom::downcast(self.ex().handle()).await
@@ -119,7 +119,7 @@ impl fmt::Debug for ForeignAtom {
 }
 impl Format for ForeignAtom {
 	async fn print<'a>(&'a self, _c: &'a (impl FmtCtx + ?Sized + 'a)) -> FmtUnit {
-		FmtUnit::from_api(&ctx().reqnot().request(api::ExtAtomPrint(self.atom.clone())).await)
+		FmtUnit::from_api(&request(api::ExtAtomPrint(self.atom.clone())).await)
 	}
 }
 impl ToExpr for ForeignAtom {
@@ -138,8 +138,8 @@ pub struct NotTypAtom {
 impl NotTypAtom {
 	pub async fn mk_err(&self) -> OrcErrv {
 		mk_errv(
-			i().i("Not the expected type").await,
-			format!("The expression {} is not a {}", fmt(&self.expr, &i()).await, self.typ.name()),
+			is("Not the expected type").await,
+			format!("The expression {} is not a {}", fmt(&self.expr).await, self.typ.name()),
 			[self.pos.clone()],
 		)
 	}
@@ -172,8 +172,10 @@ impl<A: AtomCard> MethodSetBuilder<A> {
 		self.handlers.push((
 			M::NAME,
 			Rc::new(move |a: &A, req: Pin<&mut dyn AsyncRead>, rep: Pin<&mut dyn AsyncWrite>| {
-				async { Supports::<M>::handle(a, M::decode(req).await).await.encode(rep).await }
-					.boxed_local()
+				async {
+					Supports::<M>::handle(a, M::decode(req).await.unwrap()).await.encode(rep).await.unwrap()
+				}
+				.boxed_local()
 			}),
 		));
 		self
@@ -182,7 +184,7 @@ impl<A: AtomCard> MethodSetBuilder<A> {
 	pub async fn pack(&self) -> MethodSet<A> {
 		MethodSet {
 			handlers: stream::iter(self.handlers.iter())
-				.then(async |(k, v)| (Sym::parse(k, &i()).await.unwrap(), v.clone()))
+				.then(async |(k, v)| (Sym::parse(k).await.unwrap(), v.clone()))
 				.collect()
 				.await,
 		}
@@ -234,16 +236,15 @@ impl<A: AtomicFeatures> TAtom<A> {
 	}
 	pub async fn request<M: AtomMethod>(&self, req: M) -> M::Response
 	where A: Supports<M> {
-		M::Response::decode(Pin::new(
-			&mut &(ctx().reqnot().request(api::Fwd(
+		M::Response::decode_slice(
+			&mut &(request(api::Fwd(
 				self.untyped.atom.clone(),
-				Sym::parse(M::NAME, &i()).await.unwrap().tok().to_api(),
-				enc_vec(&req).await,
+				Sym::parse(M::NAME).await.unwrap().tok().to_api(),
+				enc_vec(&req),
 			)))
 			.await
 			.unwrap()[..],
-		))
-		.await
+		)
 	}
 }
 impl<A: AtomicFeatures> Deref for TAtom<A> {
@@ -311,9 +312,18 @@ impl Format for AtomFactory {
 }
 
 pub async fn err_not_callable() -> OrcErrv {
-	mk_errv_floating(i().i("This atom is not callable").await, "Attempted to apply value as function")
+	mk_errv_floating(is("This atom is not callable").await, "Attempted to apply value as function")
 }
 
 pub async fn err_not_command() -> OrcErrv {
-	mk_errv_floating(i().i("This atom is not a command").await, "Settled on an inactionable value")
+	mk_errv_floating(is("This atom is not a command").await, "Settled on an inactionable value")
+}
+
+/// Read the type ID prefix from an atom, return type information and the rest
+/// of the data
+pub(crate) fn resolve_atom_type(atom: &api::Atom) -> (Box<dyn AtomDynfo>, AtomTypeId, &[u8]) {
+	let mut data = &atom.data.0[..];
+	let tid = AtomTypeId::decode_slice(&mut data);
+	let atom_record = atom_by_idx(cted().inst().card(), tid).expect("Unrecognized atom type ID");
+	(atom_record, tid, data)
 }