Backup commit before crunch

src/pipeline/import_resolution/apply_aliases.rs

@@ -6,6 +6,20 @@ use crate::{utils::Substack, interner::{Token, Interner}, pipeline::{ProjectModu
 
 use super::{alias_map::AliasMap, decls::InjectedAsFn};
 
+fn resolve(
+  token: Token<Vec<Token<String>>>,
+  alias_map: &AliasMap,
+  i: &Interner,
+) -> Option<Vec<Token<String>>> {
+  if let Some(alias) = alias_map.resolve(token) {
+    Some(i.r(alias).clone())
+  } else if let Some((foot, body)) = i.r(token).split_last() {
+    let mut new_beginning = resolve(i.i(body), alias_map, i)?;
+    new_beginning.push(*foot);
+    Some(new_beginning)
+  } else {None}
+}
+
 fn process_expr(
   expr: &Expr,
   alias_map: &AliasMap,
@@ -14,9 +28,15 @@ fn process_expr(
 ) -> Expr {
   expr.map_names(&|n| {
     injected_as(&i.r(n)[..]).or_else(|| {
-      alias_map.resolve(n).map(|n| {
-        injected_as(&i.r(n)[..]).unwrap_or(n)
-      })
+      let next_v = resolve(n, alias_map, i)?;
+      // println!("Resolved alias {} to {}",
+      //   i.extern_vec(n).join("::"),
+      //   i.extern_all(&next_v).join("::")
+      // );
+      Some(
+        injected_as(&next_v)
+          .unwrap_or_else(|| i.i(&next_v))
+      )
     })
   }).unwrap_or_else(|| expr.clone())
 }

src/pipeline/import_resolution/resolve_imports.rs

@@ -1,5 +1,7 @@
 use std::rc::Rc;
 
+use itertools::Itertools;
+
 use crate::interner::Interner;
 use crate::pipeline::error::ProjectError;
 use crate::pipeline::project_tree::ProjectTree;
@@ -23,6 +25,14 @@ pub fn resolve_imports(
     &project, &mut map,
     i, injected_as
   )?;
+  println!("Aliases: {{{:?}}}",
+    map.targets.iter()
+      .map(|(kt, vt)| format!("{} => {}",
+        i.extern_vec(*kt).join("::"),
+        i.extern_vec(*vt).join("::")
+      ))
+      .join(", ")
+  );
   let new_mod = apply_aliases(project.0.as_ref(), &map, i, injected_as);
   Ok(ProjectTree(Rc::new(new_mod)))
 }

src/pipeline/parse_layer.rs

@@ -39,7 +39,7 @@ pub fn parse_layer<'a>(
     ))
   };
   let source = source_loader::load_source(
-    targets, i, loader, &|path| injected_as(path).is_some()
+    targets, prelude, i, loader, &|path| injected_as(path).is_some()
   )?;
   let tree = project_tree::build_tree(source, i, prelude, &injected_names)?;
   let sum = ProjectTree(Rc::new(

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 {

src/pipeline/source_loader/load_source.rs

@@ -7,6 +7,7 @@ use crate::pipeline::split_name::split_name;
 use crate::interner::{Token, Interner};
 
 use crate::pipeline::file_loader::{Loaded, load_text, IOResult};
+use crate::representations::sourcefile::FileEntry;
 use super::loaded_source::{LoadedSourceTable, LoadedSource};
 use super::preparse::preparse;
 
@@ -15,6 +16,7 @@ use super::preparse::preparse;
 fn load_abs_path_rec(
   abs_path: Token<Vec<Token<String>>>,
   table: &mut LoadedSourceTable,
+  prelude: &[FileEntry],
   i: &Interner,
   get_source: &impl Fn(Token<Vec<Token<String>>>) -> IOResult,
   is_injected: &impl Fn(&[Token<String>]) -> bool
@@ -39,7 +41,7 @@ fn load_abs_path_rec(
         .chain(iter::once(i.i(item)))
         .collect::<Vec<_>>();
       load_abs_path_rec(
-        i.i(&abs_subpath), table, i, get_source, is_injected
+        i.i(&abs_subpath), table, prelude, i, get_source, is_injected
       )?
     }
     return Ok(());
@@ -48,7 +50,7 @@ fn load_abs_path_rec(
   let text = load_text(i.i(filename), &get_source, i)?;
   let preparsed = preparse(
     filename.iter().map(|t| i.r(*t)).cloned().collect(),
-    text.as_str(), i
+    text.as_str(), prelude, i
   )?;
   table.insert(abs_path, LoadedSource{ text, preparsed: preparsed.clone() });
   // recurse on all imported modules
@@ -58,7 +60,9 @@ fn load_abs_path_rec(
       module, &import.nonglob_path(i), i
     )?;
     // recurse on imported module
-    load_abs_path_rec(i.i(&abs_pathv), table, i, get_source, is_injected)
+    load_abs_path_rec(
+      i.i(&abs_pathv), table, prelude, i, get_source, is_injected
+    )
   })
 }
 
@@ -66,6 +70,7 @@ fn load_abs_path_rec(
 /// imports that aren't injected.
 pub fn load_source(
   targets: &[Token<Vec<Token<String>>>],
+  prelude: &[FileEntry],
   i: &Interner,
   get_source: &impl Fn(Token<Vec<Token<String>>>) -> IOResult,
   is_injected: &impl Fn(&[Token<String>]) -> bool,
@@ -75,6 +80,7 @@ pub fn load_source(
     load_abs_path_rec(
       *target,
       &mut table,
+      prelude,
       i, get_source, is_injected
     )?
   }

src/pipeline/source_loader/preparse.rs

@@ -38,23 +38,27 @@ fn add_export<K: Eq + Hash>(
 }
 
 /// Convert source lines into a module
-fn to_module(src: &[FileEntry], i: &Interner) -> Rc<Module<(), ()>>
-{
-  let imports = imports(src.iter()).cloned().collect::<Vec<_>>();
-  let mut items = src.iter().filter_map(|ent| match ent {
+fn to_module(
+  src: &[FileEntry],
+  prelude: &[FileEntry],
+  i: &Interner
+) -> Rc<Module<(), ()>> {
+  let all_src = || src.iter().chain(prelude.iter());
+  let imports = imports(all_src()).cloned().collect::<Vec<_>>();
+  let mut items = all_src().filter_map(|ent| match ent {
     FileEntry::Internal(Member::Namespace(name, data)) => {
-      let member = ModMember::Sub(to_module(data, i));
+      let member = ModMember::Sub(to_module(data, prelude, i));
       let entry = ModEntry{ exported: false, member };
       Some((*name, entry))
     }
     FileEntry::Exported(Member::Namespace(name, data)) => {
-      let member = ModMember::Sub(to_module(data, i));
+      let member = ModMember::Sub(to_module(data, prelude, i));
       let entry = ModEntry{ exported: true, member };
       Some((*name, entry))
     }
     _ => None
   }).collect::<HashMap<_, _>>();
-  for file_entry in src { match file_entry {
+  for file_entry in all_src() { match file_entry {
     FileEntry::Comment(_) | FileEntry::Import(_)
     | FileEntry::Internal(Member::Namespace(..))
     | FileEntry::Exported(Member::Namespace(..)) => (),
@@ -83,8 +87,12 @@ fn to_module(src: &[FileEntry], i: &Interner) -> Rc<Module<(), ()>>
 
 /// Preparse the module. At this stage, only the imports and
 /// names defined by the module can be parsed
-pub fn preparse(file: Vec<String>, source: &str, i: &Interner)
--> Result<Preparsed, Rc<dyn ProjectError>> {
+pub fn preparse(
+  file: Vec<String>,
+  source: &str,
+  prelude: &[FileEntry],
+  i: &Interner,
+) -> Result<Preparsed, Rc<dyn ProjectError>> {
   // Parse with no operators
   let ctx = ParsingContext::<&str>::new(&[], i, Rc::new(file.clone()));
   let entries = parse::parse(source, ctx)
@@ -98,5 +106,5 @@ pub fn preparse(file: Vec<String>, source: &str, i: &Interner)
       namespace: ns.into_iter().map(|t| i.r(t)).cloned().collect(),
       file: Rc::new(file.clone())
     }.rc())?;
-  Ok(Preparsed(to_module(&normalized, i)))
+  Ok(Preparsed(to_module(&normalized, prelude, i)))
 }