commit before easter break

orchid-host/src/lex.rs

@@ -1,30 +1,25 @@
-use std::num::NonZeroU64;
 use std::sync::Arc;
 
 use async_std::sync::Mutex;
 use futures::FutureExt;
-use hashbrown::HashMap;
 use orchid_base::error::{OrcErrv, OrcRes, mk_errv};
 use orchid_base::interner::Tok;
 use orchid_base::location::Pos;
-use orchid_base::match_mapping;
-use orchid_base::name::Sym;
-use orchid_base::number::{num_to_err, parse_num};
 use orchid_base::parse::{name_char, name_start, op_char, unrep_space};
 use orchid_base::tokens::PARENS;
-use orchid_base::tree::{AtomRepr, Ph};
+use orchid_base::tree::recur;
 
 use crate::api;
-use crate::atom::AtomHand;
 use crate::ctx::Ctx;
+use crate::expr::{Expr, ExprParseCtx};
+use crate::parsed::{ParsTok, ParsTokTree};
 use crate::system::System;
-use crate::tree::{ParsTok, ParsTokTree};
 
 pub struct LexCtx<'a> {
 	pub systems: &'a [System],
 	pub source: &'a Tok<String>,
 	pub tail: &'a str,
-	pub sub_trees: &'a mut HashMap<api::TreeTicket, ParsTokTree>,
+	pub sub_trees: &'a mut Vec<Expr>,
 	pub ctx: &'a Ctx,
 }
 impl<'a> LexCtx<'a> {
@@ -50,13 +45,24 @@ impl<'a> LexCtx<'a> {
 		}
 		false
 	}
-	pub fn add_subtree(&mut self, subtree: ParsTokTree) -> api::TreeTicket {
-		let next_idx = api::TreeTicket(NonZeroU64::new(self.sub_trees.len() as u64 + 1).unwrap());
-		self.sub_trees.insert(next_idx, subtree);
-		next_idx
+	pub async fn ser_subtree(&mut self, subtree: ParsTokTree) -> api::TokenTree {
+		let mut exprs = self.ctx.common_exprs.clone();
+		let foo = recur(subtree, &|tt, r| {
+			if let ParsTok::NewExpr(expr) = tt.tok {
+				return ParsTok::Handle(expr).at(tt.range);
+			}
+			r(tt)
+		});
+		foo.into_api(&mut exprs, &mut ()).await
 	}
-	pub fn rm_subtree(&mut self, ticket: api::TreeTicket) -> ParsTokTree {
-		self.sub_trees.remove(&ticket).unwrap()
+	pub async fn des_subtree(&mut self, tree: &api::TokenTree) -> ParsTokTree {
+		ParsTokTree::from_api(
+			&tree,
+			&mut self.ctx.common_exprs.clone(),
+			&mut ExprParseCtx { ctx: self.ctx.clone(), exprs: self.ctx.common_exprs.clone() },
+			&self.ctx.i,
+		)
+		.await
 	}
 	pub fn strip_char(&mut self, tgt: char) -> bool {
 		if let Some(src) = self.tail.strip_prefix(tgt) {
@@ -86,8 +92,12 @@ pub async fn lex_once(ctx: &mut LexCtx<'_>) -> OrcRes<ParsTokTree> {
 	);
 	let tok = if ctx.strip_prefix("\r\n") || ctx.strip_prefix("\r") || ctx.strip_prefix("\n") {
 		ParsTok::BR
-	} else if ctx.strip_prefix("::") {
-		ParsTok::NS
+	} else if let Some(tail) = (ctx.tail.starts_with(name_start).then_some(ctx.tail))
+		.and_then(|t| t.trim_start_matches(name_char).strip_prefix("::"))
+	{
+		let name = &ctx.tail[..ctx.tail.len() - tail.len() - "::".len()];
+		let body = lex_once(ctx).boxed_local().await?;
+		ParsTok::NS(ctx.ctx.i.i(name).await, Box::new(body))
 	} else if ctx.strip_prefix("--[") {
 		let Some((cmt, tail)) = ctx.tail.split_once("]--") else {
 			return Err(mk_errv(
@@ -132,20 +142,6 @@ pub async fn lex_once(ctx: &mut LexCtx<'_>) -> OrcRes<ParsTokTree> {
 			ctx.trim_ws();
 		}
 		ParsTok::S(*paren, body)
-	} else if ctx.strip_prefix("macro")
-		&& !ctx.tail.chars().next().is_some_and(|x| x.is_ascii_alphabetic())
-	{
-		ctx.strip_prefix("macro");
-		if ctx.strip_char('(') {
-			let pos = ctx.get_pos();
-			let numstr = ctx.get_start_matches(|x| x != ')').trim();
-			match parse_num(numstr) {
-				Ok(num) => ParsTok::Macro(Some(num.to_f64())),
-				Err(e) => return Err(num_to_err(e, pos, &ctx.ctx.i).await.into()),
-			}
-		} else {
-			ParsTok::Macro(None)
-		}
 	} else {
 		for sys in ctx.systems {
 			let mut errors = Vec::new();
@@ -157,7 +153,7 @@ pub async fn lex_once(ctx: &mut LexCtx<'_>) -> OrcRes<ParsTokTree> {
 					.lex(source, pos, |pos| async move {
 						let mut ctx_g = ctx_lck.lock().await;
 						match lex_once(&mut ctx_g.push(pos)).boxed_local().await {
-							Ok(t) => Some(api::SubLexed { pos: t.range.end, ticket: ctx_g.add_subtree(t) }),
+							Ok(t) => Some(api::SubLexed { pos: t.range.end, tree: ctx_g.ser_subtree(t).await }),
 							Err(e) => {
 								errors_lck.lock().await.push(e);
 								None
@@ -172,7 +168,7 @@ pub async fn lex_once(ctx: &mut LexCtx<'_>) -> OrcRes<ParsTokTree> {
 						),
 					Ok(Some(lexed)) => {
 						ctx.set_pos(lexed.pos);
-						return Ok(tt_to_owned(&lexed.expr, ctx).await);
+						return Ok(ctx.des_subtree(&lexed.expr).await);
 					},
 					Ok(None) => match errors.into_iter().reduce(|a, b| a + b) {
 						Some(errors) => return Err(errors),
@@ -196,39 +192,8 @@ pub async fn lex_once(ctx: &mut LexCtx<'_>) -> OrcRes<ParsTokTree> {
 	Ok(ParsTokTree { tok, range: start..ctx.get_pos() })
 }
 
-async fn tt_to_owned(api: &api::TokenTree, ctx: &mut LexCtx<'_>) -> ParsTokTree {
-	let tok = match_mapping!(&api.token, api::Token => ParsTok {
-		Atom(atom =>
-			AtomHand::from_api(atom, Pos::Range(api.range.clone()), &mut ctx.ctx.clone()).await
-		),
-		Bottom(err => OrcErrv::from_api(err, &ctx.ctx.i).await),
-		LambdaHead(arg => ttv_to_owned(arg, ctx).boxed_local().await),
-		Name(name => Tok::from_api(*name, &ctx.ctx.i).await),
-		Reference(tstrv => Sym::from_api(*tstrv, &ctx.ctx.i).await),
-		S(p.clone(), b => ttv_to_owned(b, ctx).boxed_local().await),
-		BR, NS,
-		Comment(c.clone()),
-		Ph(ph => Ph::from_api(ph, &ctx.ctx.i).await),
-		Macro(*prio),
-	} {
-		api::Token::Slot(id) => return ctx.rm_subtree(*id),
-	});
-	ParsTokTree { range: api.range.clone(), tok }
-}
-
-async fn ttv_to_owned<'a>(
-	api: impl IntoIterator<Item = &'a api::TokenTree>,
-	ctx: &mut LexCtx<'_>,
-) -> Vec<ParsTokTree> {
-	let mut out = Vec::new();
-	for tt in api {
-		out.push(tt_to_owned(tt, ctx).await)
-	}
-	out
-}
-
 pub async fn lex(text: Tok<String>, systems: &[System], ctx: &Ctx) -> OrcRes<Vec<ParsTokTree>> {
-	let mut sub_trees = HashMap::new();
+	let mut sub_trees = Vec::new();
 	let mut ctx = LexCtx { source: &text, sub_trees: &mut sub_trees, tail: &text[..], systems, ctx };
 	let mut tokv = Vec::new();
 	ctx.trim(unrep_space);