Commit pending merge

orchid-extension/src/entrypoint.rs

@@ -268,10 +268,11 @@ pub fn extension_init(
 							let vfs = systems_g[sys_id].vfses[vfs_id].load(&path, ctx).await;
 							hand.handle(&vfs_read, &vfs).await
 						},
-						api::HostExtReq::LexExpr(lex @ api::LexExpr { sys, text, pos, id }) => {
+						api::HostExtReq::LexExpr(lex @ api::LexExpr { sys, src, text, pos, id }) => {
 							let sys_ctx = get_ctx(sys).await;
 							let text = Tok::from_api(text, &i).await;
-							let ctx = LexContext { id, pos, text: &text, ctx: sys_ctx.clone() };
+							let src = Sym::from_api(src, sys_ctx.i()).await;
+							let ctx = LexContext { id, pos, text: &text, src, ctx: sys_ctx.clone() };
 							let trigger_char = text.chars().nth(pos as usize).unwrap();
 							let err_na = err_not_applicable(&i).await;
 							let err_cascade = err_cascade(&i).await;
@@ -294,11 +295,12 @@ pub fn extension_init(
 							hand.handle(&lex, &None).await
 						},
 						api::HostExtReq::ParseLine(pline) => {
-							let api::ParseLine { module, exported, comments, sys, line } = &pline;
+							let api::ParseLine { module, src, exported, comments, sys, line } = &pline;
 							let mut ctx = get_ctx(*sys).await;
 							let parsers = ctx.cted().inst().dyn_parsers();
+							let src = Sym::from_api(*src, ctx.i()).await;
 							let comments = join_all(comments.iter().map(|c| Comment::from_api(c, &i))).await;
-							let line: Vec<GenTokTree> = ttv_from_api(line, &mut ctx, &mut (), &i).await;
+							let line: Vec<GenTokTree> = ttv_from_api(line, &mut ctx, &mut (), &src, &i).await;
 							let snip = Snippet::new(line.first().expect("Empty line"), &line);
 							let (head, tail) = snip.pop_front().unwrap();
 							let name = if let GenTok::Name(n) = &head.tok { n } else { panic!("No line head") };

orchid-extension/src/lexer.rs

@@ -1,11 +1,12 @@
 use std::future::Future;
-use std::ops::{Range, RangeInclusive};
+use std::ops::RangeInclusive;
 
 use futures::FutureExt;
 use futures::future::LocalBoxFuture;
 use orchid_base::error::{OrcErr, OrcRes, mk_err};
 use orchid_base::interner::{Interner, Tok};
-use orchid_base::location::Pos;
+use orchid_base::location::{Pos, SrcRange};
+use orchid_base::name::Sym;
 use orchid_base::reqnot::Requester;
 
 use crate::api;
@@ -34,6 +35,7 @@ pub struct LexContext<'a> {
 	pub text: &'a Tok<String>,
 	pub id: api::ParsId,
 	pub pos: u32,
+	pub src: Sym,
 }
 impl<'a> LexContext<'a> {
 	pub async fn recurse(&self, tail: &'a str) -> OrcRes<(&'a str, GenTokTree)> {
@@ -41,14 +43,15 @@ impl<'a> LexContext<'a> {
 		let Some(lx) = self.ctx.reqnot().request(api::SubLex { pos: start, id: self.id }).await else {
 			return Err(err_cascade(self.ctx.i()).await.into());
 		};
-		let tree = GenTokTree::from_api(&lx.tree, &mut self.ctx.clone(), &mut (), self.ctx.i()).await;
+		let tree =
+			GenTokTree::from_api(&lx.tree, &mut self.ctx.clone(), &mut (), &self.src, self.ctx.i()).await;
 		Ok((&self.text[lx.pos as usize..], tree))
 	}
 
 	pub fn pos(&self, tail: &'a str) -> u32 { (self.text.len() - tail.len()) as u32 }
 
-	pub fn tok_ran(&self, len: u32, tail: &'a str) -> Range<u32> {
-		self.pos(tail) - len..self.pos(tail)
+	pub fn tok_ran(&self, len: u32, tail: &'a str) -> SrcRange {
+		SrcRange::new(self.pos(tail) - len..self.pos(tail), &self.src)
 	}
 }
 

orchid-extension/src/tree.rs

@@ -8,7 +8,7 @@ use futures::{FutureExt, StreamExt};
 use hashbrown::HashMap;
 use itertools::Itertools;
 use orchid_base::interner::{Interner, Tok};
-use orchid_base::location::Pos;
+use orchid_base::location::SrcRange;
 use orchid_base::name::Sym;
 use orchid_base::reqnot::ReqHandlish;
 use orchid_base::tree::{TokTree, Token, TokenVariant};
@@ -32,7 +32,7 @@ impl TokenVariant<api::Expression> for GExpr {
 	async fn from_api(
 		_: &api::Expression,
 		_: &mut Self::FromApiCtx<'_>,
-		_: Pos,
+		_: SrcRange,
 		_: &Interner,
 	) -> Self {
 		panic!("Received new expression from host")
@@ -47,7 +47,7 @@ impl TokenVariant<api::ExprTicket> for Expr {
 	async fn from_api(
 		api: &api::ExprTicket,
 		ctx: &mut Self::FromApiCtx<'_>,
-		_: Pos,
+		_: SrcRange,
 		_: &Interner,
 	) -> Self {
 		// SAFETY: receiving trees from sublexers implies ownership transfer