temp commit

orchid-std/src/std/number/num_atom.rs

@@ -2,9 +2,7 @@ use orchid_api_derive::Coding;
 use orchid_base::error::OrcRes;
 use orchid_base::format::FmtUnit;
 use orchid_base::number::Numeric;
-use orchid_extension::atom::{
-	AtomFactory, Atomic, AtomicFeatures, MethodSetBuilder, ToAtom, TypAtom,
-};
+use orchid_extension::atom::{AtomFactory, Atomic, AtomicFeatures, ToAtom, TypAtom};
 use orchid_extension::atom_thin::{ThinAtom, ThinVariant};
 use orchid_extension::conv::TryFromExpr;
 use orchid_extension::expr::Expr;

orchid-std/src/std/number/num_lexer.rs

@@ -4,7 +4,7 @@ use orchid_base::error::OrcRes;
 use orchid_base::number::{num_to_err, parse_num};
 use orchid_extension::atom::ToAtom;
 use orchid_extension::lexer::{LexContext, Lexer};
-use orchid_extension::tree::{GenTok, GenTokTree};
+use orchid_extension::tree::{GenTokTree, x_tok};
 
 use super::num_atom::Num;
 
@@ -12,13 +12,13 @@ use super::num_atom::Num;
 pub struct NumLexer;
 impl Lexer for NumLexer {
 	const CHAR_FILTER: &'static [RangeInclusive<char>] = &['0'..='9'];
-	async fn lex<'a>(all: &'a str, ctx: &'a LexContext<'a>) -> OrcRes<(&'a str, GenTokTree<'a>)> {
+	async fn lex<'a>(all: &'a str, ctx: &'a LexContext<'a>) -> OrcRes<(&'a str, GenTokTree)> {
 		let ends_at = all.find(|c: char| !c.is_ascii_hexdigit() && !"xX._pP".contains(c));
 		let (chars, tail) = all.split_at(ends_at.unwrap_or(all.len()));
 		let fac = match parse_num(chars) {
 			Ok(numeric) => Num(numeric).to_atom_factory(),
-			Err(e) => return Err(num_to_err(e, ctx.pos(all), ctx.i).await.into()),
+			Err(e) => return Err(num_to_err(e, ctx.pos(all), &ctx.src, ctx.ctx.i()).await.into()),
 		};
-		Ok((tail, GenTok::X(fac).at(ctx.pos(all)..ctx.pos(tail))))
+		Ok((tail, x_tok(fac).at(ctx.pos_lt(chars.len(), tail))))
 	}
 }

orchid-std/src/std/number/num_lib.rs

@@ -1,10 +1,10 @@
 use orchid_base::number::Numeric;
-use orchid_extension::tree::{GenItem, fun, prefix};
+use orchid_extension::tree::{GenMember, fun, prefix};
 use ordered_float::NotNan;
 
 use super::num_atom::{Float, HomoArray, Int, Num};
 
-pub fn gen_num_lib() -> Vec<GenItem> {
+pub fn gen_num_lib() -> Vec<GenMember> {
 	prefix("std::number", [
 		fun(true, "add", |a: Num, b: Num| async move {
 			Num(match HomoArray::new([a.0, b.0]) {

orchid-std/src/std/std_system.rs

@@ -2,12 +2,12 @@ use never::Never;
 use orchid_base::reqnot::Receipt;
 use orchid_extension::atom::{AtomDynfo, AtomicFeatures};
 use orchid_extension::entrypoint::ExtReq;
-use orchid_extension::fs::DeclFs;
+use orchid_extension::fs::DeclVmod;
 use orchid_extension::lexer::LexerObj;
 use orchid_extension::parser::ParserObj;
 use orchid_extension::system::{System, SystemCard};
 use orchid_extension::system_ctor::SystemCtor;
-use orchid_extension::tree::{GenItem, merge_trivial};
+use orchid_extension::tree::{GenMember, merge_trivial};
 
 use super::number::num_lib::gen_num_lib;
 use super::string::str_atom::{IntStrAtom, StrAtom};
@@ -36,6 +36,6 @@ impl System for StdSystem {
 	async fn request(_: ExtReq<'_>, req: Self::Req) -> Receipt<'_> { match req {} }
 	fn lexers() -> Vec<LexerObj> { vec![&StringLexer, &NumLexer] }
 	fn parsers() -> Vec<ParserObj> { vec![] }
-	fn vfs() -> DeclFs { DeclFs::Mod(&[]) }
-	fn env() -> Vec<GenItem> { merge_trivial([gen_num_lib(), gen_str_lib()]) }
+	fn vfs() -> DeclVmod { DeclVmod::new(&[]) }
+	fn env() -> Vec<GenMember> { merge_trivial([gen_num_lib(), gen_str_lib()]) }
 }

orchid-std/src/std/string/str_atom.rs

@@ -82,17 +82,17 @@ impl OwnedAtom for IntStrAtom {
 }
 
 #[derive(Clone)]
-pub struct OrcString<'a> {
-	kind: OrcStringKind<'a>,
+pub struct OrcString {
+	kind: OrcStringKind,
 	ctx: SysCtx,
 }
 
 #[derive(Clone)]
-pub enum OrcStringKind<'a> {
-	Val(TypAtom<'a, StrAtom>),
-	Int(TypAtom<'a, IntStrAtom>),
+pub enum OrcStringKind {
+	Val(TypAtom<StrAtom>),
+	Int(TypAtom<IntStrAtom>),
 }
-impl OrcString<'_> {
+impl OrcString {
 	pub async fn get_string(&self) -> Rc<String> {
 		match &self.kind {
 			OrcStringKind::Int(tok) => self.ctx.i().ex(**tok).await.rc(),
@@ -101,8 +101,8 @@ impl OrcString<'_> {
 	}
 }
 
-impl TryFromExpr for OrcString<'static> {
-	async fn try_from_expr(expr: Expr) -> OrcRes<OrcString<'static>> {
+impl TryFromExpr for OrcString {
+	async fn try_from_expr(expr: Expr) -> OrcRes<OrcString> {
 		if let Ok(v) = TypAtom::<StrAtom>::try_from_expr(expr.clone()).await {
 			return Ok(OrcString { ctx: expr.ctx(), kind: OrcStringKind::Val(v) });
 		}

orchid-std/src/std/string/str_lexer.rs

@@ -1,12 +1,12 @@
 use itertools::Itertools;
 use orchid_base::error::{OrcErr, OrcRes, mk_err, mk_errv};
 use orchid_base::interner::Interner;
-use orchid_base::location::Pos;
+use orchid_base::location::SrcRange;
+use orchid_base::name::Sym;
 use orchid_base::sym;
 use orchid_base::tree::wrap_tokv;
-use orchid_extension::atom::AtomicFeatures;
 use orchid_extension::lexer::{LexContext, Lexer, err_not_applicable};
-use orchid_extension::tree::{GenTok, GenTokTree};
+use orchid_extension::tree::{GenTokTree, ref_tok, x_tok};
 
 use super::str_atom::IntStrAtom;
 
@@ -32,7 +32,7 @@ struct StringError {
 
 impl StringError {
 	/// Convert into project error for reporting
-	pub async fn into_proj(self, pos: u32, i: &Interner) -> OrcErr {
+	pub async fn into_proj(self, path: &Sym, pos: u32, i: &Interner) -> OrcErr {
 		let start = pos + self.pos;
 		mk_err(
 			i.i("Failed to parse string").await,
@@ -41,7 +41,7 @@ impl StringError {
 				StringErrorKind::BadCodePoint => "The specified number is not a Unicode code point",
 				StringErrorKind::BadEscSeq => "Unrecognized escape sequence",
 			},
-			[Pos::Range(start..start + 1).into()],
+			[SrcRange::new(start..start + 1, path).pos().into()],
 		)
 	}
 }
@@ -95,9 +95,9 @@ fn parse_string(str: &str) -> Result<String, StringError> {
 pub struct StringLexer;
 impl Lexer for StringLexer {
 	const CHAR_FILTER: &'static [std::ops::RangeInclusive<char>] = &['"'..='"', '`'..='`'];
-	async fn lex<'a>(all: &'a str, ctx: &'a LexContext<'a>) -> OrcRes<(&'a str, GenTokTree<'a>)> {
+	async fn lex<'a>(all: &'a str, ctx: &'a LexContext<'a>) -> OrcRes<(&'a str, GenTokTree)> {
 		let Some(mut tail) = all.strip_prefix('"') else {
-			return Err(err_not_applicable(ctx.i).await.into());
+			return Err(err_not_applicable(ctx.ctx.i()).await.into());
 		};
 		let mut ret = None;
 		let mut cur = String::new();
@@ -107,19 +107,19 @@ impl Lexer for StringLexer {
 			tail: &str,
 			err: &mut Vec<OrcErr>,
 			ctx: &'a LexContext<'a>,
-		) -> GenTokTree<'a> {
+		) -> GenTokTree {
 			let str_val_res = parse_string(&str.split_off(0));
 			if let Err(e) = &str_val_res {
-				err.push(e.clone().into_proj(ctx.pos(tail) - str.len() as u32, ctx.i).await);
+				err.push(e.clone().into_proj(&ctx.src, ctx.pos(tail) - str.len() as u32, ctx.i()).await);
 			}
 			let str_val = str_val_res.unwrap_or_default();
-			GenTok::X(IntStrAtom::from(ctx.i.i(&*str_val).await).factory())
-				.at(ctx.tok_ran(str.len() as u32, tail)) as GenTokTree<'a>
+			x_tok(IntStrAtom::from(ctx.i().i(&*str_val).await)).at(ctx.pos_lt(str.len() as u32, tail))
+				as GenTokTree
 		}
-		let add_frag = |prev: Option<GenTokTree<'a>>, new: GenTokTree<'a>| async {
+		let add_frag = |prev: Option<GenTokTree>, new: GenTokTree| async {
 			let Some(prev) = prev else { return new };
-			let concat_fn =
-				GenTok::Reference(sym!(std::string::concat; ctx.i).await).at(prev.sr.start..prev.sr.start);
+			let concat_fn = ref_tok(sym!(std::string::concat; ctx.i()).await)
+				.at(SrcRange::zw(prev.sr.path(), prev.sr.start()));
 			wrap_tokv([concat_fn, prev, new])
 		};
 		loop {
@@ -141,9 +141,9 @@ impl Lexer for StringLexer {
 				} else {
 					let range = ctx.pos(all)..ctx.pos("");
 					return Err(mk_errv(
-						ctx.i.i("No string end").await,
+						ctx.i().i("No string end").await,
 						"String never terminated with \"",
-						[Pos::Range(range.clone()).into()],
+						[SrcRange::new(range.clone(), &ctx.src)],
 					));
 				}
 			}

orchid-std/src/std/string/str_lib.rs

@@ -1,14 +1,14 @@
 use std::rc::Rc;
 
-use orchid_extension::tree::{GenItem, comments, fun, prefix};
+use orchid_extension::tree::{GenMember, comments, fun, prefix};
 
 use super::str_atom::StrAtom;
 use crate::OrcString;
 
-pub fn gen_str_lib() -> Vec<GenItem> {
+pub fn gen_str_lib() -> Vec<GenMember> {
 	prefix("std::string", [comments(
 		["Concatenate two strings"],
-		fun(true, "concat", |left: OrcString<'static>, right: OrcString<'static>| async move {
+		fun(true, "concat", |left: OrcString, right: OrcString| async move {
 			StrAtom::new(Rc::new(left.get_string().await.to_string() + &right.get_string().await))
 		}),
 	)])