Preparation for sharing

- rustfmt
- clippy
- comments
- README

src/pipeline/project_tree/normalize_imports.rs

@@ -1,74 +1,88 @@
-use crate::representations::tree::{Module, ModMember};
-use crate::representations::sourcefile::{Member, FileEntry, Import};
-use crate::utils::BoxedIter;
-use crate::utils::{Substack, iter::box_once};
-use crate::interner::{Interner, Token};
-use crate::pipeline::import_abs_path::import_abs_path;
-
 use super::collect_ops::ExportedOpsCache;
+use crate::interner::{Interner, Tok};
+use crate::pipeline::import_abs_path::import_abs_path;
+use crate::representations::sourcefile::{
+  FileEntry, Import, Member, Namespace,
+};
+use crate::representations::tree::{ModMember, Module};
+use crate::utils::iter::box_once;
+use crate::utils::{BoxedIter, Substack};
 
 fn member_rec(
   // level
-  mod_stack: Substack<Token<String>>,
+  mod_stack: Substack<Tok<String>>,
   preparsed: &Module<impl Clone, impl Clone>,
   // object
   member: Member,
   // context
-  path: &[Token<String>],
+  path: &[Tok<String>],
   ops_cache: &ExportedOpsCache,
-  i: &Interner
+  i: &Interner,
 ) -> Member {
   match member {
-    Member::Namespace(name, body) => {
+    Member::Namespace(Namespace { name, body }) => {
       let prepmember = &preparsed.items[&name].member;
-      let subprep = if let ModMember::Sub(m) = prepmember {m.clone()}
-      else {unreachable!("This name must point to a namespace")};
+      let subprep = if let ModMember::Sub(m) = prepmember {
+        m.clone()
+      } else {
+        unreachable!("This name must point to a namespace")
+      };
       let new_body = entv_rec(
         mod_stack.push(name),
         subprep.as_ref(),
         body,
-        path, ops_cache, i
+        path,
+        ops_cache,
+        i,
       );
-      Member::Namespace(name, new_body)
+      Member::Namespace(Namespace { name, body: new_body })
     },
-    any => any
+    any => any,
   }
 }
 
 fn entv_rec(
   // level
-  mod_stack: Substack<Token<String>>,
+  mod_stack: Substack<Tok<String>>,
   preparsed: &Module<impl Clone, impl Clone>,
   // object
   data: Vec<FileEntry>,
   // context
-  mod_path: &[Token<String>],
+  mod_path: &[Tok<String>],
   ops_cache: &ExportedOpsCache,
-  i: &Interner
+  i: &Interner,
 ) -> Vec<FileEntry> {
-  data.into_iter()
+  data
+    .into_iter()
     .map(|ent| match ent {
-      FileEntry::Import(imps) => FileEntry::Import(imps.into_iter()
-        .flat_map(|import| if let Import{ name: None, path } = import {
-          let p = import_abs_path(
-            mod_path, mod_stack, preparsed, &i.r(path)[..], i
-          ).expect("Should have emerged in preparsing");
-          let names = ops_cache.find(&i.i(&p))
-            .expect("Should have emerged in second parsing");
-          let imports = names.iter()
-            .map(move |&n| Import{ name: Some(n), path })
-            .collect::<Vec<_>>();
-          Box::new(imports.into_iter()) as BoxedIter<Import>
-        } else {box_once(import)})
-        .collect()
+      FileEntry::Import(imps) => FileEntry::Import(
+        imps
+          .into_iter()
+          .flat_map(|import| {
+            if let Import { name: None, path } = import {
+              let p = import_abs_path(mod_path, mod_stack, &i.r(path)[..], i)
+                .expect("Should have emerged in preparsing");
+              let names = ops_cache
+                .find(&i.i(&p))
+                .expect("Should have emerged in second parsing");
+              let imports = names
+                .iter()
+                .map(move |&n| Import { name: Some(n), path })
+                .collect::<Vec<_>>();
+              Box::new(imports.into_iter()) as BoxedIter<Import>
+            } else {
+              box_once(import)
+            }
+          })
+          .collect(),
       ),
       FileEntry::Exported(mem) => FileEntry::Exported(member_rec(
-        mod_stack, preparsed, mem, mod_path, ops_cache, i
+        mod_stack, preparsed, mem, mod_path, ops_cache, i,
       )),
       FileEntry::Internal(mem) => FileEntry::Internal(member_rec(
-        mod_stack, preparsed, mem, mod_path, ops_cache, i
+        mod_stack, preparsed, mem, mod_path, ops_cache, i,
       )),
-      any => any
+      any => any,
     })
     .collect()
 }
@@ -76,9 +90,9 @@ fn entv_rec(
 pub fn normalize_imports(
   preparsed: &Module<impl Clone, impl Clone>,
   data: Vec<FileEntry>,
-  path: &[Token<String>],
+  path: &[Tok<String>],
   ops_cache: &ExportedOpsCache,
-  i: &Interner
+  i: &Interner,
 ) -> Vec<FileEntry> {
   entv_rec(Substack::Bottom, preparsed, data, path, ops_cache, i)
-}
+}