temp commit

orchid-extension/src/entrypoint.rs

@@ -5,7 +5,7 @@ use std::num::NonZero;
 use std::pin::Pin;
 use std::rc::Rc;
 
-use async_std::channel::{self, Receiver, RecvError, Sender};
+use async_std::channel::{self, Receiver, Sender};
 use async_std::stream;
 use async_std::sync::Mutex;
 use futures::future::{LocalBoxFuture, join_all};
@@ -22,7 +22,7 @@ use orchid_base::logging::Logger;
 use orchid_base::name::Sym;
 use orchid_base::parse::{Comment, Snippet};
 use orchid_base::reqnot::{ReqNot, RequestHandle, Requester};
-use orchid_base::tree::{TokenVariant, ttv_from_api, ttv_into_api};
+use orchid_base::tree::{TokenVariant, ttv_from_api};
 use substack::Substack;
 use trait_set::trait_set;
 
@@ -32,6 +32,7 @@ use crate::atom_owned::take_atom;
 use crate::expr::{Expr, ExprHandle};
 use crate::fs::VirtFS;
 use crate::lexer::{LexContext, err_cascade, err_not_applicable};
+use crate::parser::{ParsCtx, get_const, linev_into_api};
 use crate::system::{SysCtx, atom_by_idx};
 use crate::system_ctor::{CtedObj, DynSystemCtor};
 use crate::tree::{GenTok, GenTokTree, LazyMemberFactory, TreeIntoApiCtxImpl};
@@ -47,7 +48,6 @@ impl ExtensionData {
 	pub fn new(name: &'static str, systems: &'static [&'static dyn DynSystemCtor]) -> Self {
 		Self { name, systems }
 	}
-	// pub fn main(self) { extension_main(self) }
 }
 
 pub enum MemberRecord {
@@ -57,7 +57,6 @@ pub enum MemberRecord {
 
 pub struct SystemRecord {
 	vfses: HashMap<api::VfsId, &'static dyn VirtFS>,
-	declfs: api::EagerVfs,
 	lazy_members: HashMap<api::TreeId, MemberRecord>,
 	ctx: SysCtx,
 }
@@ -84,19 +83,6 @@ pub async fn with_atom_record<'a, F: Future<Output = SysCtx>, T>(
 	cb(atom_record, ctx, id, data).await
 }
 
-// pub fn extension_main(data: ExtensionData) {
-
-// 	if thread::Builder::new()
-// 		.name(format!("ext-main:{}", data.name))
-// 		.spawn(|| extension_main_logic(data))
-// 		.unwrap()
-// 		.join()
-// 		.is_err()
-// 	{
-// 		process::exit(-1)
-// 	}
-// }
-
 pub struct ExtensionOwner {
 	_interner_cell: Rc<RefCell<Option<Interner>>>,
 	_systems_lock: Rc<Mutex<HashMap<api::SysId, SystemRecord>>>,
@@ -109,12 +95,7 @@ impl ExtPort for ExtensionOwner {
 		Box::pin(async { self.out_send.send(msg.to_vec()).boxed_local().await.unwrap() })
 	}
 	fn recv(&self) -> LocalBoxFuture<'_, Option<Vec<u8>>> {
-		Box::pin(async {
-			match self.out_recv.recv().await {
-				Ok(v) => Some(v),
-				Err(RecvError) => None,
-			}
-		})
+		Box::pin(async { (self.out_recv.recv().await).ok() })
 	}
 }
 
@@ -141,8 +122,7 @@ pub fn extension_init(
 	let get_ctx = clone!(systems_weak; move |id: api::SysId| clone!(systems_weak; async move {
 		let systems =
 			systems_weak.upgrade().expect("System table dropped before request processing done");
-		let x = systems.lock().await.get(&id).expect("System not found").ctx.clone();
-		x
+		systems.lock().await.get(&id).expect("System not found").ctx.clone()
 	}));
 	let init_ctx = {
 		clone!(interner_weak, spawner, logger);
@@ -200,32 +180,25 @@ pub fn extension_init(
 								.then(|mem| {
 									let (req, lazy_mems) = (&hand, &lazy_mems);
 									clone!(i, ctx; async move {
-										let name = i.i(&mem.name).await.to_api();
-										let value = mem.kind.into_api(&mut TreeIntoApiCtxImpl {
+										let mut tia_ctx = TreeIntoApiCtxImpl {
 											lazy_members: &mut *lazy_mems.lock().await,
 											sys: ctx,
 											basepath: &[],
 											path: Substack::Bottom,
 											req
-										})
-										.await;
-										(name, value)
+										};
+										(i.i(&mem.name).await.to_api(), mem.kind.into_api(&mut tia_ctx).await)
 									})
 								})
 								.collect()
 								.await;
-							let declfs = cted.inst().dyn_vfs().to_api_rec(&mut vfses, &i).await;
-							let record =
-								SystemRecord { declfs, vfses, ctx, lazy_members: lazy_mems.into_inner() };
+							let vfs = cted.inst().dyn_vfs().to_api_rec(&mut vfses, &i).await;
+							let record = SystemRecord { vfses, ctx, lazy_members: lazy_mems.into_inner() };
 							let systems = systems_weak.upgrade().expect("System constructed during shutdown");
 							systems.lock().await.insert(new_sys.id, record);
-							hand
-								.handle(&new_sys, &api::NewSystemResponse {
-									lex_filter,
-									const_root,
-									line_types: vec![],
-								})
-								.await
+							let response =
+								api::NewSystemResponse { lex_filter, const_root, line_types: vec![], vfs };
+							hand.handle(&new_sys, &response).await
 						},
 						api::HostExtReq::GetMember(get_tree @ api::GetMember(sys_id, tree_id)) => {
 							let sys_ctx = get_ctx(sys_id).await;
@@ -248,18 +221,13 @@ pub fn extension_init(
 							};
 							hand.handle(&get_tree, &tree.into_api(&mut tia_ctx).await).await
 						},
-						api::HostExtReq::VfsReq(api::VfsReq::GetVfs(get_vfs @ api::GetVfs(sys_id))) => {
-							let systems = systems_weak.upgrade().expect("VFS root requested during shutdown");
-							let systems_g = systems.lock().await;
-							hand.handle(&get_vfs, &systems_g[&sys_id].declfs).await
-						},
 						api::HostExtReq::SysReq(api::SysReq::SysFwded(fwd)) => {
 							let api::SysFwded(sys_id, payload) = fwd;
 							let ctx = get_ctx(sys_id).await;
 							let sys = ctx.cted().inst();
 							sys.dyn_request(hand, payload).await
 						},
-						api::HostExtReq::VfsReq(api::VfsReq::VfsRead(vfs_read)) => {
+						api::HostExtReq::VfsRead(vfs_read) => {
 							let api::VfsRead(sys_id, vfs_id, path) = &vfs_read;
 							let ctx = get_ctx(*sys_id).await;
 							let systems = systems_weak.upgrade().expect("VFS requested during shutdoown");
@@ -308,13 +276,18 @@ pub fn extension_init(
 							let parser =
 								parsers.iter().find(|p| p.line_head() == **name).expect("No parser candidate");
 							let module = Sym::from_api(*module, ctx.i()).await;
-							let o_line = match parser.parse(ctx.clone(), module, *exported, comments, tail).await
-							{
+							let pctx = ParsCtx::new(ctx.clone(), module);
+							let o_line = match parser.parse(pctx, *exported, comments, tail).await {
 								Err(e) => Err(e.to_api()),
-								Ok(t) => Ok(ttv_into_api(t, &mut (), &mut (ctx.clone(), &hand)).await),
+								Ok(t) => Ok(linev_into_api(t, ctx.clone(), &hand).await),
 							};
 							hand.handle(&pline, &o_line).await
 						},
+						api::HostExtReq::FetchParsedConst(ref fpc @ api::FetchParsedConst { id, sys }) => {
+							let ctx = get_ctx(sys).await;
+							let cnst = get_const(id, ctx.clone()).await;
+							hand.handle(fpc, &cnst.api_return(ctx, &hand).await).await
+						},
 						api::HostExtReq::AtomReq(atom_req) => {
 							let atom = atom_req.get_atom();
 							let atom_req = atom_req.clone();