Preparation for sharing

- rustfmt
- clippy
- comments
- README

src/pipeline/project_tree/collect_ops/exported_ops.rs

@@ -4,73 +4,80 @@ use std::rc::Rc;
 use hashbrown::HashSet;
 use itertools::Itertools;
 
-use crate::representations::tree::WalkErrorKind;
+use crate::interner::{Interner, Sym, Tok};
+use crate::pipeline::error::{ModuleNotFound, ProjectError};
 use crate::pipeline::source_loader::LoadedSourceTable;
-use crate::pipeline::error::{ProjectError, ModuleNotFound};
-use crate::interner::{Token, Interner};
-use crate::utils::Cache;
 use crate::pipeline::split_name::split_name;
+use crate::representations::tree::WalkErrorKind;
+use crate::utils::Cache;
 
-pub type OpsResult = Result<Rc<HashSet<Token<String>>>, Rc<dyn ProjectError>>;
-pub type ExportedOpsCache<'a> = Cache<'a, Token<Vec<Token<String>>>, OpsResult>;
+pub type OpsResult = Result<Rc<HashSet<Tok<String>>>, Rc<dyn ProjectError>>;
+pub type ExportedOpsCache<'a> = Cache<'a, Sym, OpsResult>;
 
-pub trait InjectedOperatorsFn = Fn(
-  Token<Vec<Token<String>>>
-) -> Option<Rc<HashSet<Token<String>>>>;
+pub trait InjectedOperatorsFn = Fn(Sym) -> Option<Rc<HashSet<Tok<String>>>>;
 
 fn coprefix<T: Eq>(
   l: impl Iterator<Item = T>,
-  r: impl Iterator<Item = T>
+  r: impl Iterator<Item = T>,
 ) -> usize {
   l.zip(r).take_while(|(a, b)| a == b).count()
 }
 
 /// Collect all names exported by the module at the specified path
 pub fn collect_exported_ops(
-  path: Token<Vec<Token<String>>>,
+  path: Sym,
   loaded: &LoadedSourceTable,
   i: &Interner,
-  injected: &impl InjectedOperatorsFn
+  injected: &impl InjectedOperatorsFn,
 ) -> OpsResult {
   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)
+    return Ok(ops);
   }
-  let is_file = |n: &[Token<String>]| loaded.contains_key(&i.i(n));
+  let is_file = |n: &[Tok<String>]| loaded.contains_key(&i.i(n));
   let path_s = &i.r(path)[..];
   let name_split = split_name(path_s, &is_file);
-  let (fpath_v, subpath_v) = if let Some(f) = name_split {f} else {
-    return Ok(Rc::new(loaded.keys().copied()
-      .filter_map(|modname| {
-        let modname_s = i.r(modname);
-        if path_s.len() == coprefix(path_s.iter(), modname_s.iter()) {
-          Some(modname_s[path_s.len()])
-        } else {None}
-      })
-      .collect::<HashSet<_>>()
-    ))
+  let (fpath_v, subpath_v) = if let Some(f) = name_split {
+    f
+  } else {
+    return Ok(Rc::new(
+      loaded
+        .keys()
+        .copied()
+        .filter_map(|modname| {
+          let modname_s = i.r(modname);
+          if path_s.len() == coprefix(path_s.iter(), modname_s.iter()) {
+            Some(modname_s[path_s.len()])
+          } else {
+            None
+          }
+        })
+        .collect::<HashSet<_>>(),
+    ));
   };
   let fpath = i.i(fpath_v);
   let preparsed = &loaded[&fpath].preparsed;
-  let module = preparsed.0.walk(&subpath_v, false)
-    .map_err(|walk_err| match walk_err.kind {
-      WalkErrorKind::Private => unreachable!("visibility is not being checked here"),
-      WalkErrorKind::Missing => ModuleNotFound{
+  let module = preparsed.0.walk(subpath_v, false).map_err(|walk_err| {
+    match walk_err.kind {
+      WalkErrorKind::Private =>
+        unreachable!("visibility is not being checked here"),
+      WalkErrorKind::Missing => ModuleNotFound {
         file: i.extern_vec(fpath),
-        subpath: subpath_v.into_iter()
+        subpath: subpath_v
+          .iter()
           .take(walk_err.pos)
           .map(|t| i.r(*t))
           .cloned()
-          .collect()
-      }.rc(),
-    })?;
-  let out: HashSet<_> = module.items.iter()
-    .filter(|(_, v)| v.exported)
-    .map(|(k, _)| *k)
-    .collect();
+          .collect(),
+      }
+      .rc(),
+    }
+  })?;
+  let out: HashSet<_> =
+    module.items.iter().filter(|(_, v)| v.exported).map(|(k, _)| *k).collect();
   if path == i.i(&[i.i("prelude")][..]) {
     println!("%%% Prelude exported ops %%%");
     println!("{}", out.iter().map(|t| i.r(*t)).join(", "));
@@ -83,7 +90,5 @@ 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/mod.rs

@@ -2,7 +2,7 @@ mod exported_ops;
 mod ops_for;
 
 pub use exported_ops::{
-  ExportedOpsCache, OpsResult, InjectedOperatorsFn,
-  collect_exported_ops, mk_cache
+  collect_exported_ops, mk_cache, ExportedOpsCache, InjectedOperatorsFn,
+  OpsResult,
 };
-pub use ops_for::collect_ops_for;
+pub use ops_for::collect_ops_for;

src/pipeline/project_tree/collect_ops/ops_for.rs

@@ -3,20 +3,19 @@ use std::rc::Rc;
 use hashbrown::HashSet;
 use itertools::Itertools;
 
+use super::exported_ops::{ExportedOpsCache, OpsResult};
+use crate::interner::{Interner, Tok};
 use crate::parse::is_op;
 use crate::pipeline::error::ProjectError;
-use crate::pipeline::source_loader::LoadedSourceTable;
-use crate::interner::{Token, Interner};
-use crate::representations::tree::{Module, ModMember};
 use crate::pipeline::import_abs_path::import_abs_path;
-
-use super::exported_ops::{ExportedOpsCache, OpsResult};
+use crate::pipeline::source_loader::LoadedSourceTable;
+use crate::representations::tree::{ModMember, Module};
 
 /// Collect all operators and names, exported or local, defined in this
 /// tree.
 fn tree_all_ops(
   module: &Module<impl Clone, impl Clone>,
-  ops: &mut HashSet<Token<String>>
+  ops: &mut HashSet<Tok<String>>,
 ) {
   ops.extend(module.items.keys().copied());
   for ent in module.items.values() {
@@ -28,21 +27,22 @@ fn tree_all_ops(
 
 /// Collect all names imported in this file
 pub fn collect_ops_for(
-  file: &[Token<String>],
+  file: &[Tok<String>],
   loaded: &LoadedSourceTable,
   ops_cache: &ExportedOpsCache,
-  i: &Interner
+  i: &Interner,
 ) -> 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 {
+  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");
+      let path = import_abs_path(file, modpath, &i.r(import.path)[..], i)
+        .expect("This error should have been caught during loading");
       ret.extend(ops_cache.find(&i.i(&path))?.iter().copied());
     }
     Ok::<_, Rc<dyn ProjectError>>(())
@@ -53,4 +53,4 @@ pub fn collect_ops_for(
     println!("{}", ret.iter().map(|t| i.r(*t)).join(", "))
   }
   Ok(Rc::new(ret))
-}
+}