Temporary commit to try fix halting

orchid-extension/src/atom.rs

@@ -13,7 +13,8 @@ use futures::{AsyncRead, AsyncWrite, FutureExt, StreamExt, stream};
 use orchid_api_derive::Coding;
 use orchid_api_traits::{Coding, Decode, Encode, Request, enc_vec};
 use orchid_base::clone;
-use orchid_base::error::{OrcErrv, OrcRes, mk_errv, mk_errv_floating};
+use orchid_base::ctx::Ctx;
+use orchid_base::error::{OrcErr, OrcRes};
 use orchid_base::format::{FmtCtx, FmtUnit, Format};
 use orchid_base::interner::Interner;
 use orchid_base::location::Pos;
@@ -135,12 +136,10 @@ pub struct NotTypAtom {
 	pub ctx: SysCtx,
 }
 impl NotTypAtom {
-	pub async fn mk_err(&self) -> OrcErrv {
-		mk_errv(
-			self.ctx.i().i("Not the expected type").await,
-			format!("This expression is not a {}", self.typ.name()),
-			[self.pos.clone()],
-		)
+	pub fn mk_err(&self, ctx: &Ctx) -> OrcErr {
+		ctx.mk_err("Not the expected type", format!("This expression is not a {}", self.typ.name()), [
+			self.pos.clone(),
+		])
 	}
 }
 
@@ -329,10 +328,10 @@ impl Format for AtomFactory {
 	}
 }
 
-pub async fn err_not_callable(i: &Interner) -> OrcErrv {
-	mk_errv_floating(i.i("This atom is not callable").await, "Attempted to apply value as function")
+pub fn err_not_callable(cx: &Ctx) -> OrcErr {
+	cx.mk_err_floating("This atom is not callable", "Attempted to apply value as function")
 }
 
-pub async fn err_not_command(i: &Interner) -> OrcErrv {
-	mk_errv_floating(i.i("This atom is not a command").await, "Settled on an inactionable value")
+pub fn err_not_command(cx: &Ctx) -> OrcErr {
+	cx.mk_err_floating("This atom is not a command", "Settled on an inactionable value")
 }

orchid-extension/src/conv.rs

@@ -1,7 +1,7 @@
 use std::future::Future;
 
 use never::Never;
-use orchid_base::error::{OrcErrv, OrcRes, mk_errv};
+use orchid_base::error::{OrcErrv, OrcRes, mk_err};
 use orchid_base::interner::Interner;
 use orchid_base::location::Pos;
 
@@ -25,11 +25,11 @@ impl<T: TryFromExpr, U: TryFromExpr> TryFromExpr for (T, U) {
 }
 
 async fn err_not_atom(pos: Pos, i: &Interner) -> OrcErrv {
-	mk_errv(i.i("Expected an atom").await, "This expression is not an atom", [pos])
+	mk_err(i.i("Expected an atom").await, "This expression is not an atom", [pos])
 }
 
 async fn err_type(pos: Pos, i: &Interner) -> OrcErrv {
-	mk_errv(i.i("Type error").await, "The atom is a different type than expected", [pos])
+	mk_err(i.i("Type error").await, "The atom is a different type than expected", [pos])
 }
 
 impl TryFromExpr for ForeignAtom {

orchid-extension/src/entrypoint.rs

@@ -49,7 +49,7 @@ impl ExtensionData {
 }
 
 pub enum MemberRecord {
-	Gen(Vec<Tok<String>>, LazyMemberFactory),
+	Gen(Vec<IStr>, LazyMemberFactory),
 	Res,
 }
 

orchid-extension/src/interner.rs

@@ -0,0 +1,7 @@
+use orchid_base::interner::{ApiStrTok, ApiStrvTok, IStr};
+
+pub struct ExtIStr(ApiStrTok, Rc<String>);
+impl Deref for ExtIStr {}
+pub struct ExtIStrv(ApiStrvTok, Rc<Vec<IStr>>);
+
+pub struct ExtInterner {}

orchid-extension/src/lexer.rs

@@ -4,7 +4,7 @@ use std::ops::RangeInclusive;
 
 use futures::FutureExt;
 use futures::future::LocalBoxFuture;
-use orchid_base::error::{OrcErrv, OrcRes, Reporter, mk_errv};
+use orchid_base::error::{OrcErrv, OrcRes, Reporter, mk_err};
 use orchid_base::interner::{Interner, Tok};
 use orchid_base::location::{Pos, SrcRange};
 use orchid_base::name::Sym;
@@ -17,27 +17,27 @@ use crate::parser::PTokTree;
 use crate::system::SysCtx;
 use crate::tree::GenTokTree;
 
-pub async fn ekey_cascade(i: &Interner) -> Tok<String> {
+pub async fn ekey_cascade(i: &Interner) -> IStr {
 	i.i("An error cascading from a recursive call").await
 }
-pub async fn ekey_not_applicable(i: &Interner) -> Tok<String> {
+pub async fn ekey_not_applicable(i: &Interner) -> IStr {
 	i.i("Pseudo-error to communicate that the current branch in a dispatch doesn't apply").await
 }
 const MSG_INTERNAL_ERROR: &str = "This error is a sentinel for the extension library.\
 	it should not be emitted by the extension.";
 
 pub async fn err_cascade(i: &Interner) -> OrcErrv {
-	mk_errv(ekey_cascade(i).await, MSG_INTERNAL_ERROR, [Pos::None])
+	mk_err(ekey_cascade(i).await, MSG_INTERNAL_ERROR, [Pos::None])
 }
 
 pub async fn err_not_applicable(i: &Interner) -> OrcErrv {
-	mk_errv(ekey_not_applicable(i).await, MSG_INTERNAL_ERROR, [Pos::None])
+	mk_err(ekey_not_applicable(i).await, MSG_INTERNAL_ERROR, [Pos::None])
 }
 
 pub struct LexContext<'a> {
 	pub(crate) exprs: &'a BorrowedExprStore,
 	pub ctx: SysCtx,
-	pub text: &'a Tok<String>,
+	pub text: &'a IStr,
 	pub id: api::ParsId,
 	pub pos: u32,
 	pub(crate) src: Sym,

orchid-extension/src/lib.rs

@@ -11,6 +11,7 @@ pub mod func_atom;
 pub mod gen_expr;
 pub mod lexer;
 // pub mod msg;
+mod interner;
 pub mod other_system;
 pub mod parser;
 pub mod reflection;

orchid-extension/src/parser.rs

@@ -115,7 +115,7 @@ impl ParsedLine {
 		sr: &SrcRange,
 		comments: impl IntoIterator<Item = &'a Comment>,
 		exported: bool,
-		name: Tok<String>,
+		name: IStr,
 		f: F,
 	) -> Self {
 		let cb = Box::new(|ctx| async move { f(ctx).await.to_expr().await }.boxed_local());
@@ -127,7 +127,7 @@ impl ParsedLine {
 		sr: &SrcRange,
 		comments: impl IntoIterator<Item = &'a Comment>,
 		exported: bool,
-		name: &Tok<String>,
+		name: &IStr,
 		use_prelude: bool,
 		lines: impl IntoIterator<Item = ParsedLine>,
 	) -> Self {
@@ -175,7 +175,7 @@ pub enum ParsedLineKind {
 }
 
 pub struct ParsedMem {
-	pub name: Tok<String>,
+	pub name: IStr,
 	pub exported: bool,
 	pub kind: ParsedMemKind,
 }

orchid-extension/src/reflection.rs

@@ -32,7 +32,7 @@ pub struct ReflModData {
 	inferred: Mutex<bool>,
 	path: VPath,
 	ctx: WeakSysCtx,
-	members: MemoMap<Tok<String>, ReflMem>,
+	members: MemoMap<IStr, ReflMem>,
 }
 
 #[derive(Clone)]
@@ -41,7 +41,7 @@ impl ReflMod {
 	fn ctx(&self) -> SysCtx {
 		self.0.ctx.upgrade().expect("ReflectedModule accessed after context drop")
 	}
-	pub fn path(&self) -> &[Tok<String>] { &self.0.path[..] }
+	pub fn path(&self) -> &[IStr] { &self.0.path[..] }
 	pub fn is_root(&self) -> bool { self.0.path.is_empty() }
 	async fn try_populate(&self) -> Result<(), api::LsModuleError> {
 		let ctx = self.ctx();
@@ -70,7 +70,7 @@ impl ReflMod {
 		}
 		Ok(())
 	}
-	pub async fn get_child(&self, key: &Tok<String>) -> Option<ReflMem> {
+	pub async fn get_child(&self, key: &IStr) -> Option<ReflMem> {
 		let inferred_g = self.0.inferred.lock().await;
 		if let Some(mem) = self.0.members.get(key) {
 			return Some(mem.clone());
@@ -88,7 +88,7 @@ impl ReflMod {
 		}
 		self.0.members.get(key).cloned()
 	}
-	pub async fn get_by_path(&self, path: &[Tok<String>]) -> Result<ReflMem, InvalidPathError> {
+	pub async fn get_by_path(&self, path: &[IStr]) -> Result<ReflMem, InvalidPathError> {
 		let ctx = self.ctx();
 		let (next, tail) = path.split_first().expect("Attempted to walk by empty path");
 		let inferred_g = self.0.inferred.lock().await;

orchid-extension/src/tree.rs

@@ -206,21 +206,21 @@ impl MemKind {
 pub trait TreeIntoApiCtx {
 	fn sys(&self) -> SysCtx;
 	fn with_lazy(&mut self, fac: LazyMemberFactory) -> api::TreeId;
-	fn push_path(&mut self, seg: Tok<String>) -> impl TreeIntoApiCtx;
+	fn push_path(&mut self, seg: IStr) -> impl TreeIntoApiCtx;
 	fn req(&self) -> &impl ReqHandlish;
 }
 
 pub struct TreeIntoApiCtxImpl<'a, 'b, RH: ReqHandlish> {
 	pub sys: SysCtx,
-	pub basepath: &'a [Tok<String>],
-	pub path: Substack<'a, Tok<String>>,
+	pub basepath: &'a [IStr],
+	pub path: Substack<'a, IStr>,
 	pub lazy_members: &'b mut HashMap<api::TreeId, MemberRecord>,
 	pub req: &'a RH,
 }
 
 impl<RH: ReqHandlish> TreeIntoApiCtx for TreeIntoApiCtxImpl<'_, '_, RH> {
 	fn sys(&self) -> SysCtx { self.sys.clone() }
-	fn push_path(&mut self, seg: Tok<String>) -> impl TreeIntoApiCtx {
+	fn push_path(&mut self, seg: IStr) -> impl TreeIntoApiCtx {
 		TreeIntoApiCtxImpl {
 			req: self.req,
 			lazy_members: self.lazy_members,