Traditional route appears to work

Beginnings of dylib extensions, entirely untestted

orchid-extension/src/entrypoint.rs

@@ -15,7 +15,7 @@ use orchid_api_traits::{Decode, Encode, Request, UnderRoot, enc_vec};
 use orchid_base::char_filter::{char_filter_match, char_filter_union, mk_char_filter};
 use orchid_base::error::try_with_reporter;
 use orchid_base::interner::{es, is, with_interner};
-use orchid_base::logging::{Logger, with_logger};
+use orchid_base::logging::{log, with_logger};
 use orchid_base::name::Sym;
 use orchid_base::parse::{Comment, Snippet};
 use orchid_base::reqnot::{
@@ -35,6 +35,7 @@ use crate::ext_port::ExtPort;
 use crate::func_atom::with_funs_ctx;
 use crate::interner::new_interner;
 use crate::lexer::{LexContext, ekey_cascade, ekey_not_applicable};
+use crate::logger::LoggerImpl;
 use crate::parser::{PTokTree, ParsCtx, get_const, linev_into_api, with_parsed_const_ctx};
 use crate::reflection::with_refl_roots;
 use crate::system::{SysCtx, atom_by_idx, cted, with_sys};
@@ -58,9 +59,17 @@ pub async fn with_comm<F: Future>(c: Rc<dyn Client>, ctx: CommCtx, fut: F) -> F:
 	CLIENT.scope(c, CTX.scope(Rc::new(RefCell::new(Some(ctx))), fut)).await
 }
 
+task_local! {
+	pub static MUTE_REPLY: ();
+}
+
 /// Send a request through the global client's [ClientExt::request]
 pub async fn request<T: Request + UnderRoot<Root = ExtHostReq>>(t: T) -> T::Response {
-	get_client().request(t).await.unwrap()
+	let response = get_client().request(t).await.unwrap();
+	if MUTE_REPLY.try_with(|b| *b).is_err() {
+		writeln!(log("msg"), "Got response {response:?}").await;
+	}
+	response
 }
 
 /// Send a notification through the global client's [ClientExt::notify]
@@ -79,15 +88,7 @@ task_local! {
 }
 
 async fn with_sys_record<F: Future>(id: api::SysId, fut: F) -> F::Output {
-	let cted = SYSTEM_TABLE.with(|tbl| {
-		eprintln!(
-			"Existing systems are {}",
-			tbl.borrow().iter().map(|(k, v)| format!("{k:?}={:?}", v.cted)).join(";")
-		);
-		let sys = tbl.borrow().get(&id).expect("Invalid sys ID").cted.clone();
-		eprintln!("Selected {:?}", sys);
-		sys
-	});
+	let cted = SYSTEM_TABLE.with(|tbl| tbl.borrow().get(&id).expect("Invalid sys ID").cted.clone());
 	with_sys(SysCtx(id, cted), fut).await
 }
 
@@ -126,8 +127,7 @@ impl ExtensionBuilder {
 		self.add_context(with_lazy_member_store);
 		self.add_context(with_refl_roots);
 		(ctx.spawn)(Box::pin(async move {
-			let api::HostHeader { log_strategy, msg_logs } =
-				api::HostHeader::decode(ctx.input.as_mut()).await.unwrap();
+			let host_header = api::HostHeader::decode(ctx.input.as_mut()).await.unwrap();
 			let decls = (self.systems.iter().enumerate())
 				.map(|(id, sys)| (u16::try_from(id).expect("more than u16max system ctors"), sys))
 				.map(|(id, sys)| sys.decl(api::SysDeclId(NonZero::new(id + 1).unwrap())))
@@ -137,24 +137,26 @@ impl ExtensionBuilder {
 				.await
 				.unwrap();
 			ctx.output.as_mut().flush().await.unwrap();
-			let logger = Logger::new(log_strategy);
-			let logger2 = logger.clone();
-			let msg_logger = Logger::new(msg_logs);
-			let (client, ctx, run_extension) = io_comm(
-				Rc::new(Mutex::new(ctx.output)),
-				Mutex::new(ctx.input),
-				async move |n: Box<dyn MsgReader<'_>>| {
-					match n.read().await.unwrap() {
+			let logger1 = LoggerImpl::from_api(&host_header.logger);
+			let logger2 = logger1.clone();
+			let (client, comm_ctx, extension_srv) =
+				io_comm(Rc::new(Mutex::new(ctx.output)), Mutex::new(ctx.input));
+			let extension_fut = extension_srv.listen(
+				async |n: Box<dyn MsgReader<'_>>| {
+					let notif = n.read().await.unwrap();
+					match notif {
 						api::HostExtNotif::Exit => exit().await,
 					}
 					Ok(())
 				},
-				async move |mut reader| {
+				async |mut reader| {
 					with_stash(async {
 						let req = reader.read_req().await.unwrap();
 						let handle = reader.finish().await;
+						// Atom printing is never reported because it generates too much
+						// noise
 						if !matches!(req, api::HostExtReq::AtomReq(api::AtomReq::AtomPrint(_))) {
-							writeln!(msg_logger, "{} extension received request {req:?}", self.name);
+							writeln!(log("msg"), "{} extension received request {req:?}", self.name).await;
 						}
 						match req {
 							api::HostExtReq::SystemDrop(sys_drop) => {
@@ -266,11 +268,6 @@ impl ExtensionBuilder {
 									let ekey_na = ekey_not_applicable().await;
 									let ekey_cascade = ekey_cascade().await;
 									let lexers = cted().inst().dyn_lexers();
-									writeln!(
-										logger,
-										"sys={sys:?}, tc={trigger_char}, lexers={}",
-										lexers.iter().map(|l| format!("{l:?}")).join(",")
-									);
 									for lx in
 										lexers.iter().filter(|l| char_filter_match(l.char_filter(), trigger_char))
 									{
@@ -290,7 +287,7 @@ impl ExtensionBuilder {
 											},
 										}
 									}
-									writeln!(logger, "Got notified about n/a character '{trigger_char}'");
+									writeln!(log("warn"), "Got notified about n/a character '{trigger_char}'").await;
 									expr_store.dispose().await;
 									handle.reply(&lex, &None).await
 								})
@@ -423,16 +420,16 @@ impl ExtensionBuilder {
 							logger2,
 							with_comm(
 								Rc::new(client),
-								ctx,
+								comm_ctx,
 								(self.context.into_iter()).fold(
-									Box::pin(async move { run_extension.await.unwrap() }) as LocalBoxFuture<()>,
+									Box::pin(async { extension_fut.await.unwrap() }) as LocalBoxFuture<()>,
 									|fut, cx| cx.apply(fut),
 								),
 							),
 						),
 					),
 				)
-				.await
+				.await;
 		}) as Pin<Box<_>>);
 	}
 }