temp commit

orchid-host/src/extension.rs

@@ -13,7 +13,6 @@ use futures::future::{join, join_all};
 use futures::{StreamExt, stream};
 use hashbrown::HashMap;
 use itertools::Itertools;
-use orchid_api::{HostMsgSet, LsModule};
 use orchid_api_traits::Request;
 use orchid_base::builtin::ExtInit;
 use orchid_base::clone;
@@ -26,8 +25,10 @@ use orchid_base::reqnot::{DynRequester, ReqNot, Requester as _};
 use crate::api;
 use crate::atom::AtomHand;
 use crate::ctx::Ctx;
+use crate::dealias::{ChildError, ChildErrorKind, walk};
 use crate::expr_store::ExprStore;
 use crate::system::SystemCtor;
+use crate::tree::MemberKind;
 
 pub struct ReqPair<R: Request>(R, Sender<R::Response>);
 
@@ -38,7 +39,6 @@ pub struct ReqPair<R: Request>(R, Sender<R::Response>);
 #[derive(destructure)]
 pub struct ExtensionData {
 	ctx: Ctx,
-	init: Rc<ExtInit>,
 	reqnot: ReqNot<api::HostMsgSet>,
 	systems: Vec<SystemCtor>,
 	logger: Logger,
@@ -85,7 +85,6 @@ impl Extension {
 					.map(|decl| SystemCtor { decl, ext: WeakExtension(weak.clone()) })
 					.collect(),
 				logger: logger.clone(),
-				init: init.clone(),
 				next_pars: RefCell::new(NonZeroU64::new(1).unwrap()),
 				lex_recur: Mutex::default(),
 				reqnot: ReqNot::new(
@@ -168,8 +167,52 @@ impl Extension {
 											})
 											.await
 									},
-									api::ExtHostReq::LsModule(ref ls @ LsModule(ref sys, ref path)) => {
-										todo!() // TODO
+									api::ExtHostReq::LsModule(ref ls @ api::LsModule(_sys, path)) => {
+										let reply: <api::LsModule as Request>::Response = 'reply: {
+											let path = i.ex(path).await;
+											let root = (ctx.root.read().await.upgrade())
+												.expect("LSModule called when root isn't in context");
+											let root_data = &mut *root.0.write().await;
+											let mut walk_ctx = (ctx.clone(), &mut root_data.consts);
+											let module =
+												match walk(&root_data.root, false, path.iter().cloned(), &mut walk_ctx)
+													.await
+												{
+													Ok(module) => module,
+													Err(ChildError { kind, .. }) =>
+														break 'reply Err(match kind {
+															ChildErrorKind::Private => panic!("Access checking was disabled"),
+															ChildErrorKind::Constant => api::LsModuleError::IsConstant,
+															ChildErrorKind::Missing => api::LsModuleError::InvalidPath,
+														}),
+												};
+											let mut members = std::collections::HashMap::new();
+											for (k, v) in &module.members {
+												let kind = match v.kind(ctx.clone(), &mut root_data.consts).await {
+													MemberKind::Const => api::MemberInfoKind::Constant,
+													MemberKind::Module(_) => api::MemberInfoKind::Module,
+												};
+												members.insert(k.to_api(), api::MemberInfo { public: v.public, kind });
+											}
+											Ok(api::ModuleInfo { members })
+										};
+										hand.handle(ls, &reply).await
+									},
+									api::ExtHostReq::ResolveNames(ref rn) => {
+										let api::ResolveNames { constid, names, sys } = rn;
+										let mut resolver = {
+											let systems = ctx.systems.read().await;
+											let weak_sys = systems.get(sys).expect("ResolveNames for invalid sys");
+											let sys = weak_sys.upgrade().expect("ResolveNames after sys drop");
+											sys.name_resolver(*constid).await
+										};
+										let mut responses = vec![const { None }; names.len()];
+										for (i, name) in names.iter().enumerate() {
+											if let Some(abs) = resolver(&ctx.i.ex(*name).await[..]).await {
+												responses[i] = Some(abs.to_sym(&ctx.i).await.to_api())
+											}
+										}
+										hand.handle(rn, &responses).await
 									},
 									api::ExtHostReq::ExtAtomPrint(ref eap @ api::ExtAtomPrint(ref atom)) => {
 										let atom = AtomHand::new(atom.clone(), &ctx).await;
@@ -184,11 +227,16 @@ impl Extension {
 			}
 		})))
 	}
-	pub(crate) fn reqnot(&self) -> &ReqNot<HostMsgSet> { &self.0.reqnot }
+	#[must_use]
+	pub(crate) fn reqnot(&self) -> &ReqNot<api::HostMsgSet> { &self.0.reqnot }
+	#[must_use]
 	pub fn ctx(&self) -> &Ctx { &self.0.ctx }
+	#[must_use]
 	pub fn logger(&self) -> &Logger { &self.0.logger }
 	pub fn system_ctors(&self) -> impl Iterator<Item = &SystemCtor> { self.0.systems.iter() }
+	#[must_use]
 	pub fn exprs(&self) -> &ExprStore { &self.0.exprs }
+	#[must_use]
 	pub async fn is_own_sys(&self, id: api::SysId) -> bool {
 		let sys = self.ctx().system_inst(id).await.expect("invalid sender sys id");
 		Rc::ptr_eq(&self.0, &sys.ext().0)
@@ -196,6 +244,7 @@ impl Extension {
 	pub async fn assert_own_sys(&self, id: api::SysId) {
 		assert!(self.is_own_sys(id).await, "Incoming message impersonates separate system");
 	}
+	#[must_use]
 	pub fn next_pars(&self) -> NonZeroU64 {
 		let mut next_pars = self.0.next_pars.borrow_mut();
 		*next_pars = next_pars.checked_add(1).unwrap_or(NonZeroU64::new(1).unwrap());
@@ -240,10 +289,12 @@ impl Extension {
 			rc.ctx().systems.write().await.remove(&id);
 		}))
 	}
+	#[must_use]
 	pub fn downgrade(&self) -> WeakExtension { WeakExtension(Rc::downgrade(&self.0)) }
 }
 
 pub struct WeakExtension(Weak<ExtensionData>);
 impl WeakExtension {
+	#[must_use]
 	pub fn upgrade(&self) -> Option<Extension> { self.0.upgrade().map(Extension) }
 }