Returned from Italy

orchid-extension/src/entrypoint.rs

@@ -30,7 +30,6 @@ use crate::api;
 use crate::atom::{AtomCtx, AtomDynfo, AtomTypeId};
 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};
@@ -56,7 +55,6 @@ pub enum MemberRecord {
 }
 
 pub struct SystemRecord {
-	vfses: HashMap<api::VfsId, &'static dyn VirtFS>,
 	lazy_members: HashMap<api::TreeId, MemberRecord>,
 	ctx: SysCtx,
 }
@@ -169,7 +167,6 @@ pub fn extension_init(
 							let (sys_id, _) = (decls.iter().enumerate().find(|(_, s)| s.id == new_sys.system))
 								.expect("NewSystem call received for invalid system");
 							let cted = data.systems[sys_id].new_system(&new_sys);
-							let mut vfses = HashMap::new();
 							let lex_filter =
 								cted.inst().dyn_lexers().iter().fold(api::CharFilter(vec![]), |cf, lx| {
 									char_filter_union(&cf, &mk_char_filter(lx.char_filter().iter().cloned()))
@@ -192,12 +189,10 @@ pub fn extension_init(
 								})
 								.collect()
 								.await;
-							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 record = SystemRecord { 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);
-							let response =
-								api::NewSystemResponse { lex_filter, const_root, line_types: vec![], vfs };
+							let response = api::NewSystemResponse { lex_filter, const_root, line_types: vec![] };
 							hand.handle(&new_sys, &response).await
 						},
 						api::HostExtReq::GetMember(get_tree @ api::GetMember(sys_id, tree_id)) => {
@@ -227,15 +222,6 @@ pub fn extension_init(
 							let sys = ctx.cted().inst();
 							sys.dyn_request(hand, payload).await
 						},
-						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");
-							let systems_g = systems.lock().await;
-							let path = join_all(path.iter().map(|t| Tok::from_api(*t, &i))).await;
-							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, src, text, pos, id }) => {
 							let sys_ctx = get_ctx(sys).await;
 							let text = Tok::from_api(text, &i).await;

orchid-extension/src/fs.rs

@@ -1,88 +0,0 @@
-use std::borrow::Cow;
-use std::num::NonZero;
-
-use futures::FutureExt;
-use futures::future::LocalBoxFuture;
-use hashbrown::HashMap;
-use orchid_base::interner::{Interner, Tok};
-use orchid_base::pure_seq::pushed;
-
-use crate::api;
-use crate::system::SysCtx;
-
-pub trait VirtFS: Send + Sync + 'static {
-	fn load<'a>(
-		&'a self,
-		path: &'a [Tok<String>],
-		ctx: SysCtx,
-	) -> LocalBoxFuture<'a, api::OrcResult<api::Loaded>>;
-}
-
-#[derive(Clone)]
-pub struct DeclVmod(Cow<'static, [(&'static str, DeclFs)]>);
-impl DeclVmod {
-	pub fn new(items: &'static [(&'static str, DeclFs)]) -> DeclVmod {
-		DeclVmod(Cow::Borrowed(items))
-	}
-	pub fn entry(
-		key: &'static str,
-		items: &'static [(&'static str, DeclFs)],
-	) -> (&'static str, DeclVmod) {
-		(key, DeclVmod(Cow::Borrowed(items)))
-	}
-	pub fn merge(&self, other: &Self) -> Result<Self, Vec<&'static str>> {
-		let mut items = Vec::new();
-		for (k, v1) in self.0.iter() {
-			items.push((*k, match other.0.iter().find(|(k2, _)| k == k2) {
-				Some((_, v2)) => v1.merge(v2).map_err(|e| pushed::<_, Vec<_>>(e, *k))?,
-				None => v1.clone(),
-			}));
-		}
-		for (k, v) in other.0.iter() {
-			if !items.iter().any(|(k2, _)| k2 == k) {
-				items.push((*k, v.clone()))
-			}
-		}
-		Ok(Self(Cow::Owned(items)))
-	}
-	pub async fn to_api_rec(
-		&self,
-		vfses: &mut HashMap<api::VfsId, &'static dyn VirtFS>,
-		i: &Interner,
-	) -> std::collections::HashMap<api::TStr, api::EagerVfs> {
-		let mut output = std::collections::HashMap::new();
-		for (k, v) in self.0.iter() {
-			output.insert(i.i::<String>(*k).await.to_api(), v.to_api_rec(vfses, i).boxed_local().await);
-		}
-		output
-	}
-}
-
-#[derive(Clone)]
-pub enum DeclFs {
-	Lazy(&'static dyn VirtFS),
-	Mod(DeclVmod),
-}
-impl DeclFs {
-	pub fn merge(&self, other: &Self) -> Result<Self, Vec<&'static str>> {
-		match (self, other) {
-			(Self::Mod(m1), Self::Mod(m2)) => Ok(Self::Mod(m1.merge(m2)?)),
-			(..) => Err(Vec::new()),
-		}
-	}
-	pub async fn to_api_rec(
-		&self,
-		vfses: &mut HashMap<api::VfsId, &'static dyn VirtFS>,
-		i: &Interner,
-	) -> api::EagerVfs {
-		match self {
-			DeclFs::Lazy(fs) => {
-				let vfsc: u16 = vfses.len().try_into().expect("too many vfses (more than u16::MAX)");
-				let id = api::VfsId(NonZero::new(vfsc + 1).unwrap());
-				vfses.insert(id, *fs);
-				api::EagerVfs::Lazy(id)
-			},
-			DeclFs::Mod(m) => api::EagerVfs::Eager(m.to_api_rec(vfses, i).await),
-		}
-	}
-}

orchid-extension/src/lib.rs

@@ -6,7 +6,6 @@ pub mod atom_thin;
 pub mod conv;
 pub mod entrypoint;
 pub mod expr;
-pub mod fs;
 pub mod func_atom;
 pub mod gen_expr;
 pub mod lexer;

orchid-extension/src/system.rs

@@ -18,7 +18,6 @@ use orchid_base::reqnot::{Receipt, ReqNot};
 use crate::api;
 use crate::atom::{AtomCtx, AtomDynfo, AtomTypeId, AtomicFeatures, ForeignAtom, TypAtom, get_info};
 use crate::entrypoint::ExtReq;
-use crate::fs::DeclVmod;
 use crate::func_atom::Fun;
 use crate::lexer::LexerObj;
 use crate::parser::ParserObj;
@@ -83,7 +82,6 @@ impl<T: SystemCard> DynSystemCard for T {
 /// System as defined by author
 pub trait System: Send + Sync + SystemCard + 'static {
 	fn env() -> Vec<GenMember>;
-	fn vfs() -> DeclVmod;
 	fn lexers() -> Vec<LexerObj>;
 	fn parsers() -> Vec<ParserObj>;
 	fn request(hand: ExtReq<'_>, req: Self::Req) -> impl Future<Output = Receipt<'_>>;
@@ -91,7 +89,6 @@ pub trait System: Send + Sync + SystemCard + 'static {
 
 pub trait DynSystem: Send + Sync + DynSystemCard + 'static {
 	fn dyn_env(&self) -> Vec<GenMember>;
-	fn dyn_vfs(&self) -> DeclVmod;
 	fn dyn_lexers(&self) -> Vec<LexerObj>;
 	fn dyn_parsers(&self) -> Vec<ParserObj>;
 	fn dyn_request<'a>(&self, hand: ExtReq<'a>, req: Vec<u8>) -> LocalBoxFuture<'a, Receipt<'a>>;
@@ -100,7 +97,6 @@ pub trait DynSystem: Send + Sync + DynSystemCard + 'static {
 
 impl<T: System> DynSystem for T {
 	fn dyn_env(&self) -> Vec<GenMember> { Self::env() }
-	fn dyn_vfs(&self) -> DeclVmod { Self::vfs() }
 	fn dyn_lexers(&self) -> Vec<LexerObj> { Self::lexers() }
 	fn dyn_parsers(&self) -> Vec<ParserObj> { Self::parsers() }
 	fn dyn_request<'a>(&self, hand: ExtReq<'a>, req: Vec<u8>) -> LocalBoxFuture<'a, Receipt<'a>> {