Added support for defining macros in Rust within the macro system

Also fixed a lot of bugs

orchid-std/src/macros/macro_line.rs

@@ -1,31 +1,24 @@
-use std::borrow::Cow;
 use std::cell::RefCell;
 use std::rc::Rc;
 
 use async_once_cell::OnceCell;
 use futures::{StreamExt, stream};
-use hashbrown::{HashMap, HashSet};
 use itertools::Itertools;
-use never::Never;
 use orchid_base::error::{OrcRes, Reporter, mk_errv};
-use orchid_base::interner::Tok;
-use orchid_base::location::Pos;
-use orchid_base::name::Sym;
 use orchid_base::parse::{
 	Comment, ParseCtx, Parsed, Snippet, expect_end, expect_tok, line_items, token_errv,
 	try_pop_no_fluff,
 };
 use orchid_base::tree::{Paren, Token};
 use orchid_base::{clone, sym};
-use orchid_extension::atom::{Atomic, TypAtom};
-use orchid_extension::atom_owned::{OwnedAtom, OwnedVariant};
+use orchid_extension::atom::TAtom;
 use orchid_extension::conv::{ToExpr, TryFromExpr};
 use orchid_extension::gen_expr::{atom, call, sym_ref};
 use orchid_extension::parser::{PSnippet, ParsCtx, ParsedLine, Parser};
 
 use crate::macros::let_line::{dealias_mac_v, parse_tokv};
+use crate::macros::macro_value::{Macro, MacroData, Matcher, Rule};
 use crate::macros::mactree::{glossary_v, map_mactree_v};
-use crate::macros::recur_state::{RecurState, RulePath};
 use crate::macros::rule::matcher::{NamedMatcher, PriodMatcher};
 use crate::{Int, MacTok};
 
@@ -48,42 +41,46 @@ impl Parser for MacroLine {
 			));
 		}
 		let module = ctx.module();
-		let Parsed { output, tail } = try_pop_no_fluff(&ctx, line).await?;
+		let Parsed { output: prio_or_body, tail } = try_pop_no_fluff(&ctx, line).await?;
 		let bad_first_item_err = || {
-			token_errv(&ctx, output, "Expected priority or block", |s| {
+			token_errv(&ctx, prio_or_body, "Expected priority or block", |s| {
 				format!("Expected a priority number or a () block, found {s}")
 			})
 		};
-		let (prio, body) = match &output.tok {
-			Token::S(Paren::Round, body) => (None, body),
-			Token::Handle(expr) => match TypAtom::<Int>::try_from_expr(expr.clone()).await {
+		let (prio, body) = match &prio_or_body.tok {
+			Token::S(Paren::Round, body) => {
+				expect_end(&ctx, tail).await?;
+				(None, body)
+			},
+			Token::Handle(expr) => match TAtom::<Int>::try_from_expr(expr.clone()).await {
 				Err(e) => {
 					return Err(e + bad_first_item_err().await);
 				},
 				Ok(prio) => {
-					let Token::S(Paren::Round, block) = &output.tok else {
+					let Parsed { output: body, tail } = try_pop_no_fluff(&ctx, tail).await?;
+					let Token::S(Paren::Round, block) = &body.tok else {
 						return Err(
-							token_errv(&ctx, output, "Expected () block", |s| {
+							token_errv(&ctx, prio_or_body, "Expected () block", |s| {
 								format!("Expected a () block, found {s}")
 							})
 							.await,
 						);
 					};
+					expect_end(&ctx, tail).await?;
 					(Some(prio), block)
 				},
 			},
 			_ => return Err(bad_first_item_err().await),
 		};
-		expect_end(&ctx, tail).await?;
-		let lines = line_items(&ctx, Snippet::new(output, body)).await;
+		let lines = line_items(&ctx, Snippet::new(prio_or_body, body)).await;
 		let Some((kw_line, rule_lines)) = lines.split_first() else { return Ok(Vec::new()) };
-		let mut keywords = HashMap::new();
+		let mut keywords = Vec::new();
 		let Parsed { tail: kw_tail, .. } =
 			expect_tok(&ctx, kw_line.tail, ctx.i().i("keywords").await).await?;
 		for kw_tok in kw_tail.iter().filter(|kw| !kw.is_fluff()) {
 			match kw_tok.as_name() {
 				Some(kw) => {
-					keywords.insert(kw, kw_tok.sr());
+					keywords.push((kw, kw_tok.sr()));
 				},
 				None => ctx.rep().report(
 					token_errv(&ctx, kw_tok, "invalid macro keywords list", |tok| {
@@ -93,7 +90,7 @@ impl Parser for MacroLine {
 				),
 			}
 		}
-		let Some(macro_name) = keywords.keys().next().cloned() else {
+		let Some((macro_name, _)) = keywords.first().cloned() else {
 			return Err(mk_errv(
 				ctx.i().i("macro with no keywords").await,
 				"Macros must define at least one macro of their own.",
@@ -103,9 +100,8 @@ impl Parser for MacroLine {
 		let mut rules = Vec::new();
 		let mut lines = Vec::new();
 		for (idx, line) in rule_lines.iter().enumerate().map(|(n, v)| (n as u32, v)) {
-			let path = RulePath { module: module.clone(), main_kw: macro_name.clone(), rule: idx };
 			let sr = line.tail.sr();
-			let name = ctx.i().i(&path.name()).await;
+			let name = ctx.i().i(&format!("rule::{}::{}", macro_name, idx)).await;
 			let Parsed { tail, .. } = expect_tok(&ctx, line.tail, ctx.i().i("rule").await).await?;
 			let arrow_token = ctx.i().i("=>").await;
 			let Some((pattern, body)) = tail.split_once(|tok| tok.is_kw(arrow_token.clone())) else {
@@ -132,7 +128,7 @@ impl Parser for MacroLine {
 				]
 			}
 			let body_sr = body.sr();
-			rules.push((name.clone(), placeholders, rules.len() as u32, sr.pos(), pattern));
+			rules.push((name.clone(), placeholders, pattern));
 			lines.push(ParsedLine::cnst(&sr, &line.output, true, name, async move |ctx| {
 				let rep = Reporter::new();
 				let body = dealias_mac_v(body_mactree, &ctx, &rep).await;
@@ -140,25 +136,23 @@ impl Parser for MacroLine {
 				if let Some(e) = rep.errv() {
 					return Err(e);
 				}
-				Ok(call([
-					sym_ref(sym!(macros::resolve_recur; ctx.i()).await),
-					atom(RecurState::base(path)),
-					macro_input.to_expr().await,
-				]))
+				Ok(call(sym_ref(sym!(macros::lower; ctx.i()).await), [call(
+					sym_ref(sym!(macros::resolve; ctx.i()).await),
+					[macro_input.to_expr().await],
+				)]))
 			}))
 		}
 		let mac_cell = Rc::new(OnceCell::new());
-		let keywords = Rc::new(keywords);
 		let rules = Rc::new(RefCell::new(Some(rules)));
 		for (kw, sr) in &*keywords {
-			clone!(mac_cell, keywords, rules, module, prio);
+			clone!(mac_cell, rules, module, prio);
 			lines.push(ParsedLine::cnst(&sr.clone(), &comments, true, kw.clone(), async move |cctx| {
 				let mac = mac_cell
 					.get_or_init(async {
 						let rep = Reporter::new();
 						let rules = rules.borrow_mut().take().expect("once cell initializer runs");
 						let rules = stream::iter(rules)
-							.then(|(body_name, placeholders, index, pos, pattern_macv)| {
+							.then(|(body_name, placeholders, pattern_macv)| {
 								let cctx = &cctx;
 								let rep = &rep;
 								let prio = &prio;
@@ -171,8 +165,7 @@ impl Parser for MacroLine {
 									};
 									let placeholders = placeholders.into_iter().map(|(ph, _)| ph.name).collect_vec();
 									match pattern_res {
-										Ok(pattern) =>
-											Some(Rule { index, pos, body_name, pattern, glossary, placeholders }),
+										Ok(pattern) => Some(Rule { body_name, pattern, glossary, placeholders }),
 										Err(e) => {
 											rep.report(e);
 											None
@@ -183,8 +176,7 @@ impl Parser for MacroLine {
 							.flat_map(stream::iter)
 							.collect::<Vec<_>>()
 							.await;
-						let own_kws = keywords.keys().cloned().collect_vec();
-						Macro(Rc::new(MacroData { module, prio: prio.map(|i| i.0 as u64), rules, own_kws }))
+						Macro(Rc::new(MacroData { module, prio: prio.map(|i| i.0 as u64), rules }))
 					})
 					.await;
 				atom(mac.clone())
@@ -193,36 +185,3 @@ impl Parser for MacroLine {
 		Ok(lines)
 	}
 }
-
-#[derive(Debug)]
-pub struct MacroData {
-	pub module: Sym,
-	pub prio: Option<u64>,
-	pub rules: Vec<Rule>,
-	pub own_kws: Vec<Tok<String>>,
-}
-
-#[derive(Clone, Debug)]
-pub struct Macro(pub Rc<MacroData>);
-#[derive(Debug)]
-pub struct Rule {
-	pub index: u32,
-	pub pos: Pos,
-	pub pattern: Matcher,
-	pub glossary: HashSet<Sym>,
-	pub placeholders: Vec<Tok<String>>,
-	pub body_name: Tok<String>,
-}
-#[derive(Debug)]
-pub enum Matcher {
-	Named(NamedMatcher),
-	Priod(PriodMatcher),
-}
-impl Atomic for Macro {
-	type Data = ();
-	type Variant = OwnedVariant;
-}
-impl OwnedAtom for Macro {
-	type Refs = Never;
-	async fn val(&self) -> Cow<'_, Self::Data> { Cow::Owned(()) }
-}