Backup commit before crunch

src/pipeline/project_tree/build_tree.rs

@@ -1,6 +1,7 @@
 use std::rc::Rc;
 
 use hashbrown::HashMap;
+use itertools::Itertools;
 
 use crate::pipeline::error::ProjectError;
 use crate::interner::{Token, Interner};
@@ -138,6 +139,11 @@ fn source_to_module(
       _ => None,
     })
     .collect::<HashMap<_, _>>();
+  // println!(
+  //   "Constructing file-module {} with members ({})",
+  //   i.extern_all(&path_v[..]).join("::"),
+  //   exports.keys().map(|t| i.r(*t)).join(", ")
+  // );
   Rc::new(Module {
     imports,
     items,
@@ -174,10 +180,15 @@ fn files_to_module(
       (namespace, ModEntry{ exported: true, member })
     })
     .collect::<HashMap<_, _>>();
-  let exports = items.keys()
+  let exports: HashMap<_, _> = items.keys()
     .copied()
     .map(|name| (name, i.i(&pushed(&path_v, name))))
     .collect();
+  // println!(
+  //   "Constructing module {} with items ({})",
+  //   i.extern_all(&path_v[..]).join("::"),
+  //   exports.keys().map(|t| i.r(*t)).join(", ")
+  // );
   Rc::new(Module{
     items,
     imports: vec![],

src/pipeline/project_tree/collect_ops/exported_ops.rs

@@ -1,6 +1,8 @@
+use std::println;
 use std::rc::Rc;
 
 use hashbrown::HashSet;
+use itertools::Itertools;
 
 use crate::representations::tree::WalkErrorKind;
 use crate::pipeline::source_loader::LoadedSourceTable;
@@ -30,7 +32,13 @@ pub fn collect_exported_ops(
   i: &Interner,
   injected: &impl InjectedOperatorsFn
 ) -> OpsResult {
-  if let Some(i) = injected(path) {return Ok(i)}
+  if let Some(ops) = injected(path) {
+    if path == i.i(&[i.i("prelude")][..]) {
+      println!("%%% Prelude exported ops %%%");
+      println!("{}", ops.iter().map(|t| i.r(*t)).join(", "));
+    }
+    return Ok(ops)
+  }
   let is_file = |n: &[Token<String>]| loaded.contains_key(&i.i(n));
   let path_s = &i.r(path)[..];
   let name_split = split_name(path_s, &is_file);
@@ -59,11 +67,15 @@ pub fn collect_exported_ops(
           .collect()
       }.rc(),
     })?;
-  Ok(Rc::new(module.items.iter()
+  let out: HashSet<_> = module.items.iter()
     .filter(|(_, v)| v.exported)
     .map(|(k, _)| *k)
-    .collect()
-  ))
+    .collect();
+  if path == i.i(&[i.i("prelude")][..]) {
+    println!("%%% Prelude exported ops %%%");
+    println!("{}", out.iter().map(|t| i.r(*t)).join(", "));
+  }
+  Ok(Rc::new(out))
 }
 
 pub fn mk_cache<'a>(
@@ -71,5 +83,7 @@ pub fn mk_cache<'a>(
   i: &'a Interner,
   injected: &'a impl InjectedOperatorsFn,
 ) -> ExportedOpsCache<'a> {
-  Cache::new(|path, _this| collect_exported_ops(path, loaded, i, injected))
+  Cache::new(|path, _this| {
+    collect_exported_ops(path, loaded, i, injected)
+  })
 }

src/pipeline/project_tree/collect_ops/ops_for.rs

@@ -1,6 +1,7 @@
 use std::rc::Rc;
 
 use hashbrown::HashSet;
+use itertools::Itertools;
 
 use crate::parse::is_op;
 use crate::pipeline::error::ProjectError;
@@ -34,9 +35,11 @@ pub fn collect_ops_for(
 ) -> OpsResult {
   let tree = &loaded[&i.i(file)].preparsed.0;
   let mut ret = HashSet::new();
+  println!("collecting ops for {}", i.extern_all(file).join("::"));
   tree_all_ops(tree.as_ref(), &mut ret);
   tree.visit_all_imports(&mut |modpath, module, import| {
     if let Some(n) = import.name { ret.insert(n); } else {
+      println!("\tglob import from {}", i.extern_vec(import.path).join("::"));
       let path = import_abs_path(
         &file, modpath, module, &i.r(import.path)[..], i
       ).expect("This error should have been caught during loading");
@@ -45,5 +48,9 @@ pub fn collect_ops_for(
     Ok::<_, Rc<dyn ProjectError>>(())
   })?;
   ret.drain_filter(|t| !is_op(i.r(*t)));
+  if file == &[i.i("map")][..] {
+    println!(" %%% ops in map %%% ");
+    println!("{}", ret.iter().map(|t| i.r(*t)).join(", "))
+  }
   Ok(Rc::new(ret))
 }

src/pipeline/project_tree/const_tree.rs

@@ -5,7 +5,7 @@ use hashbrown::HashMap;
 use crate::representations::tree::{ModEntry, ModMember, Module};
 use crate::representations::Primitive;
 use crate::representations::location::Location;
-use crate::foreign::ExternFn;
+use crate::foreign::{ExternFn, Atomic, Atom};
 use crate::interner::{Token, Interner};
 use crate::ast::{Expr, Clause};
 use crate::utils::{Substack, pushed};
@@ -17,12 +17,18 @@ pub enum ConstTree {
   Tree(HashMap<Token<String>, ConstTree>)
 }
 impl ConstTree {
-  pub fn xfn(xfn: impl ExternFn + 'static) -> Self {
+  pub fn primitive(primitive: Primitive) -> Self {
     Self::Const(Expr{
       location: Location::Unknown,
-      value: Clause::P(Primitive::ExternFn(Box::new(xfn)))
+      value: Clause::P(primitive)
     })
   }
+  pub fn xfn(xfn: impl ExternFn + 'static) -> Self {
+    Self::primitive(Primitive::ExternFn(Box::new(xfn)))
+  }
+  pub fn atom(atom: impl Atomic + 'static) -> Self {
+    Self::primitive(Primitive::Atom(Atom(Box::new(atom))))
+  }
   pub fn tree(
     arr: impl IntoIterator<Item = (Token<String>, Self)>
   ) -> Self {