Removed a copious amount of premature Rc-s

src/pipeline/source_loader/load_source.rs

@@ -3,22 +3,22 @@ use std::rc::Rc;
 
 use super::loaded_source::{LoadedSource, LoadedSourceTable};
 use super::preparse::preparse;
-use crate::interner::{Interner, Sym};
-use crate::pipeline::error::ProjectError;
-use crate::pipeline::file_loader::{load_text, IOResult, Loaded};
+use crate::interner::{Interner, Tok};
+use crate::pipeline::error::{ProjectError, UnexpectedDirectory};
+use crate::pipeline::file_loader::{IOResult, Loaded};
 use crate::pipeline::import_abs_path::import_abs_path;
 use crate::representations::sourcefile::FileEntry;
-use crate::utils::split_max_prefix;
+use crate::utils::{split_max_prefix, unwrap_or};
 
 /// Load the source at the given path or all within if it's a collection,
 /// and all sources imported from these.
 fn load_abs_path_rec(
-  abs_path: Sym,
+  abs_path: &[Tok<String>],
   table: &mut LoadedSourceTable,
   prelude: &[FileEntry],
   i: &Interner,
-  get_source: &impl Fn(Sym) -> IOResult,
-  is_injected_module: &impl Fn(Sym) -> bool,
+  get_source: &impl Fn(&[Tok<String>]) -> IOResult,
+  is_injected_module: &impl Fn(&[Tok<String>]) -> bool,
 ) -> Result<(), Rc<dyn ProjectError>> {
   // # Termination
   //
@@ -29,23 +29,26 @@ fn load_abs_path_rec(
   // contains no cycles.
 
   // Termination: exit if entry already visited
-  if table.contains_key(&abs_path) {
+  if table.contains_key(abs_path) {
     return Ok(());
   }
 
   // try splitting the path to file, swallowing any IO errors
-  let is_file = |sym| get_source(sym).map(|l| l.is_code()).unwrap_or(false);
-  let name_split = split_max_prefix(&i.r(abs_path)[..], &|p| is_file(i.i(p)));
+  let name_split = split_max_prefix(abs_path, &|p| {
+    get_source(p).map(|l| l.is_code()).unwrap_or(false)
+  });
   if let Some((filename, _)) = name_split {
     // if the filename is valid, load, preparse and record this file
-    let text = load_text(i.i(filename), &get_source, i)?;
+    let text = unwrap_or!(get_source(filename)? => Loaded::Code; {
+      return Err(UnexpectedDirectory { path: i.extern_all(filename) }.rc())
+    });
     let preparsed = preparse(
       filename.iter().map(|t| i.r(*t)).cloned().collect(),
       text.as_str(),
       prelude,
       i,
     )?;
-    table.insert(i.i(filename), LoadedSource {
+    table.insert(filename.to_vec(), LoadedSource {
       text,
       preparsed: preparsed.clone(),
     });
@@ -55,7 +58,7 @@ fn load_abs_path_rec(
         import_abs_path(filename, modpath, &import.nonglob_path(i), i)?;
       // recurse on imported module
       load_abs_path_rec(
-        i.i(&abs_pathv),
+        &abs_pathv,
         table,
         prelude,
         i,
@@ -70,20 +73,20 @@ fn load_abs_path_rec(
       Ok(Loaded::Code(_)) =>
         unreachable!("split_name returned None but the path is a file"),
       Err(e) => {
-        let parent = i.r(abs_path).split_last().expect("import path nonzero").1;
+        let parent = abs_path.split_last().expect("import path nonzero").1;
         // exit without error if it was injected, or raise any IO error that was
         // previously swallowed
-        return if is_injected_module(i.i(parent)) { Ok(()) } else { Err(e) };
+        return if is_injected_module(parent) { Ok(()) } else { Err(e) };
       },
     };
     // recurse on all files and folders within
     for item in coll.iter() {
-      let abs_subpath = (i.r(abs_path).iter())
+      let abs_subpath = (abs_path.iter())
         .copied()
         .chain(iter::once(i.i(item)))
         .collect::<Vec<_>>();
       load_abs_path_rec(
-        i.i(&abs_subpath),
+        &abs_subpath,
         table,
         prelude,
         i,
@@ -101,17 +104,17 @@ fn load_abs_path_rec(
 /// is_injected_module must return false for injected symbols, but may return
 /// true for parents of injected modules that are not directly part of the
 /// injected data (the ProjectTree doesn't make a distinction between the two)
-pub fn load_source(
-  targets: &[Sym],
+pub fn load_source<'a>(
+  targets: impl Iterator<Item = &'a [Tok<String>]>,
   prelude: &[FileEntry],
   i: &Interner,
-  get_source: &impl Fn(Sym) -> IOResult,
-  is_injected_module: &impl Fn(Sym) -> bool,
+  get_source: &impl Fn(&[Tok<String>]) -> IOResult,
+  is_injected_module: &impl Fn(&[Tok<String>]) -> bool,
 ) -> Result<LoadedSourceTable, Rc<dyn ProjectError>> {
   let mut table = LoadedSourceTable::new();
   for target in targets {
     load_abs_path_rec(
-      *target,
+      target,
       &mut table,
       prelude,
       i,