New macro system and stdlib additions

orchid-extension/src/parser.rs

@@ -16,10 +16,10 @@ use orchid_base::reqnot::Requester;
 use orchid_base::tree::{TokTree, Token, ttv_into_api};
 
 use crate::api;
+use crate::context::{SysCtxEntry, ctx, i};
 use crate::conv::ToExpr;
 use crate::expr::Expr;
 use crate::gen_expr::GExpr;
-use crate::system::{SysCtx, SysCtxEntry};
 use crate::tree::{GenTok, GenTokTree};
 
 pub type PTok = Token<Expr, Never>;
@@ -81,19 +81,18 @@ pub type ParserObj = &'static dyn DynParser;
 
 pub struct ParsCtx<'a> {
 	_parse: PhantomData<&'a mut ()>,
-	ctx: SysCtx,
 	module: Sym,
 	reporter: &'a Reporter,
+	i: Interner,
 }
 impl<'a> ParsCtx<'a> {
-	pub(crate) fn new(ctx: SysCtx, module: Sym, reporter: &'a Reporter) -> Self {
-		Self { _parse: PhantomData, ctx, module, reporter }
+	pub(crate) fn new(module: Sym, reporter: &'a Reporter) -> Self {
+		Self { _parse: PhantomData, module, reporter, i: i() }
 	}
-	pub fn ctx(&self) -> &SysCtx { &self.ctx }
 	pub fn module(&self) -> Sym { self.module.clone() }
 }
 impl ParseCtx for ParsCtx<'_> {
-	fn i(&self) -> &Interner { self.ctx.i() }
+	fn i(&self) -> &Interner { &self.i }
 	fn rep(&self) -> &Reporter { self.reporter }
 }
 
@@ -118,7 +117,7 @@ impl ParsedLine {
 		name: Tok<String>,
 		f: F,
 	) -> Self {
-		let cb = Box::new(|ctx| async move { f(ctx).await.to_expr().await }.boxed_local());
+		let cb = Box::new(|ctx| async move { f(ctx).await.to_gen().await }.boxed_local());
 		let kind = ParsedLineKind::Mem(ParsedMem { name, exported, kind: ParsedMemKind::Const(cb) });
 		let comments = comments.into_iter().cloned().collect();
 		ParsedLine { comments, sr: sr.clone(), kind }
@@ -136,7 +135,7 @@ impl ParsedLine {
 		let comments = comments.into_iter().cloned().collect();
 		ParsedLine { comments, sr: sr.clone(), kind: line_kind }
 	}
-	pub async fn into_api(self, mut ctx: SysCtx) -> api::ParsedLine {
+	pub async fn into_api(self) -> api::ParsedLine {
 		api::ParsedLine {
 			comments: self.comments.into_iter().map(|c| c.to_api()).collect(),
 			source_range: self.sr.to_api(),
@@ -146,23 +145,23 @@ impl ParsedLine {
 					exported: mem.exported,
 					kind: match mem.kind {
 						ParsedMemKind::Const(cb) => api::ParsedMemberKind::Constant(api::ParsedConstId(
-							ctx.get_or_default::<ParsedConstCtxEntry>().consts.add(cb).id(),
+							ctx().get_or_default::<ParsedConstCtxEntry>().consts.add(cb).id(),
 						)),
 						ParsedMemKind::Mod { lines, use_prelude } => api::ParsedMemberKind::Module {
-							lines: linev_into_api(lines, ctx).boxed_local().await,
+							lines: linev_into_api(lines).boxed_local().await,
 							use_prelude,
 						},
 					},
 				}),
 				ParsedLineKind::Rec(tv) =>
-					api::ParsedLineKind::Recursive(ttv_into_api(tv, &mut (), &mut ctx).await),
+					api::ParsedLineKind::Recursive(ttv_into_api(tv, &mut (), &mut ()).await),
 			},
 		}
 	}
 }
 
-pub(crate) async fn linev_into_api(v: Vec<ParsedLine>, ctx: SysCtx) -> Vec<api::ParsedLine> {
-	join_all(v.into_iter().map(|l| l.into_api(ctx.clone()))).await
+pub(crate) async fn linev_into_api(v: Vec<ParsedLine>) -> Vec<api::ParsedLine> {
+	join_all(v.into_iter().map(|l| l.into_api())).await
 }
 
 pub enum ParsedLineKind {
@@ -183,26 +182,23 @@ pub enum ParsedMemKind {
 
 #[derive(Clone)]
 pub struct ConstCtx {
-	ctx: SysCtx,
 	constid: api::ParsedConstId,
 }
 impl ConstCtx {
-	pub fn ctx(&self) -> &SysCtx { &self.ctx }
-	pub fn i(&self) -> &Interner { self.ctx.i() }
 	pub fn names<'b>(
 		&'b self,
 		names: impl IntoIterator<Item = &'b Sym> + 'b,
 	) -> impl Stream<Item = OrcRes<Sym>> + 'b {
 		let resolve_names = api::ResolveNames {
 			constid: self.constid,
-			sys: self.ctx.sys_id(),
+			sys: ctx().sys_id(),
 			names: names.into_iter().map(|n| n.to_api()).collect_vec(),
 		};
 		stream(async |mut cx| {
-			for name_opt in self.ctx.reqnot().request(resolve_names).await {
+			for name_opt in ctx().reqnot().request(resolve_names).await {
 				cx.emit(match name_opt {
-					Err(e) => Err(OrcErrv::from_api(&e, self.ctx.i()).await),
-					Ok(name) => Ok(Sym::from_api(name, self.ctx.i()).await),
+					Err(e) => Err(OrcErrv::from_api(&e, &i()).await),
+					Ok(name) => Ok(Sym::from_api(name, &i()).await),
 				})
 				.await
 			}
@@ -213,9 +209,9 @@ impl ConstCtx {
 	}
 }
 
-pub(crate) async fn get_const(id: api::ParsedConstId, ctx: SysCtx) -> GExpr {
-	let ent = ctx.get_or_default::<ParsedConstCtxEntry>();
-	let rec = ent.consts.get(id.0).expect("Bad ID or double read of parsed const");
-	let ctx = ConstCtx { constid: id, ctx: ctx.clone() };
-	rec.remove()(ctx).await
+pub(crate) async fn get_const(id: api::ParsedConstId) -> GExpr {
+	let cb = (ctx().get_or_default::<ParsedConstCtxEntry>().consts.get(id.0))
+		.expect("Bad ID or double read of parsed const")
+		.remove();
+	cb(ConstCtx { constid: id }).await
 }