temp commit

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))
 		}),
 	)])