[fine] Oh no a runtime and module loading and stuff

Lots of test work to use the new mechanism. I'm not sure I like it.

fine/src/lib.rs

@@ -1,8 +1,8 @@
-use std::{fs, rc::Rc};
+use std::{collections::HashMap, fs, rc::Rc};
 
 use compiler::compile;
 use parser::parse;
-use semantics::{check, Semantics};
+use semantics::{check, Error, Semantics};
 use vm::{eval, Context};
 
 pub mod compiler;
@@ -11,38 +11,139 @@ pub mod semantics;
 pub mod tokens;
 pub mod vm;
 
-// struct SourceModule {
-//     semantics: Rc<Semantics>,
-// }
+pub enum ModuleSource {
+    SourceText(String),
+}
 
-// impl SourceModule {
-//     pub fn new(source: &str) -> Self {
-//         let source: Rc<str> = source.into();
-//         let (syntax, lines) = parse(&source);
-//         let semantics = Rc::new(Semantics::new(source, syntax, lines));
-//         SourceModule { semantics }
-//     }
-// }
+#[derive(Debug)]
+pub enum ModuleLoadError {
+    IO(std::io::Error),
+}
 
-// struct Environment {}
+pub trait ModuleLoader {
+    fn normalize_module_name(&self, name: String) -> String;
+    fn load_module(&self, name: &String) -> Result<ModuleSource, ModuleLoadError>;
+}
+
+pub struct StandardModuleLoader {}
+
+impl ModuleLoader for StandardModuleLoader {
+    fn normalize_module_name(&self, name: String) -> String {
+        match std::fs::canonicalize(&name) {
+            Ok(p) => match p.into_os_string().into_string() {
+                Ok(s) => s,
+                Err(_) => name,
+            },
+            Err(_) => name,
+        }
+    }
+
+    fn load_module(&self, name: &String) -> Result<ModuleSource, ModuleLoadError> {
+        match fs::read_to_string(name) {
+            Ok(c) => Ok(ModuleSource::SourceText(c)),
+            Err(e) => Err(ModuleLoadError::IO(e)),
+        }
+    }
+}
+
+pub struct Module {
+    module: Rc<compiler::Module>,
+    semantics: Rc<Semantics>,
+}
+
+impl Module {
+    pub fn semantics(&self) -> Rc<Semantics> {
+        self.semantics.clone()
+    }
+
+    pub fn compiled(&self) -> Rc<compiler::Module> {
+        self.module.clone()
+    }
+}
+
+pub struct Runtime {
+    modules: HashMap<String, Rc<Module>>,
+    loader: Box<dyn ModuleLoader>,
+}
+
+impl Runtime {
+    pub fn new(loader: Box<dyn ModuleLoader>) -> Self {
+        Runtime {
+            modules: HashMap::new(),
+            loader,
+        }
+    }
+
+    pub fn load_module(&mut self, name: &str) -> Result<(Vec<Error>, Rc<Module>), ModuleLoadError> {
+        let mut init_pending = HashMap::new();
+        let mut names = Vec::new();
+        let name = self.loader.normalize_module_name(name.to_string());
+        names.push(name.clone());
+
+        while let Some(name) = names.pop() {
+            if self.modules.contains_key(&name) {
+                continue;
+            }
+            if !init_pending.contains_key(&name) {
+                let loaded = self.loader.load_module(&name)?;
+                match loaded {
+                    ModuleSource::SourceText(source) => {
+                        let source: Rc<str> = source.into();
+                        let (tree, lines) = parse(&source);
+                        let semantics = Rc::new(Semantics::new(source, tree, lines));
+
+                        let mut normalized = Vec::new();
+                        for import in semantics.imports() {
+                            let import = self.loader.normalize_module_name(import);
+                            names.push(import.clone());
+                            normalized.push(import);
+                        }
+
+                        init_pending.insert(name, (normalized, semantics));
+                    }
+                }
+            }
+        }
+
+        for (_, (imports, semantics)) in init_pending.iter() {
+            let mut import_table = HashMap::new();
+            for import in imports.iter() {
+                let target = if let Some(module) = self.modules.get(&*import) {
+                    Rc::downgrade(&module.semantics)
+                } else {
+                    Rc::downgrade(&init_pending.get(&*import).unwrap().1)
+                };
+                import_table.insert(import.clone(), target);
+            }
+            semantics.set_imports(import_table);
+        }
+
+        let mut errors = Vec::new();
+        for (name, (_, semantics)) in init_pending.into_iter() {
+            check(&semantics);
+            errors.append(&mut semantics.snapshot_errors());
+            let module = compile(&semantics);
+            self.modules
+                .insert(name, Rc::new(Module { semantics, module }));
+        }
+
+        let result = self.modules.get(&name).unwrap().clone();
+        Ok((errors, result))
+    }
+}
 
 pub fn process_file(file: &str) {
-    let source = match fs::read_to_string(file) {
-        Ok(c) => c,
-        Err(e) => {
-            eprintln!("Unable to read file {file}: {e}");
+    let mut runtime = Runtime::new(Box::new(StandardModuleLoader {}));
+
+    let (errors, module) = match runtime.load_module(file) {
+        Ok(r) => r,
+        Err(_) => {
+            eprintln!("Error loading module");
             return;
         }
     };
 
-    // What am I doing here?
-    let source: Rc<str> = source.into();
-    let (tree, lines) = parse(&source);
-    let semantics = Rc::new(Semantics::new(source, tree, lines));
-    check(&semantics);
-
     // OK now there might be errors.
-    let errors = semantics.snapshot_errors();
     if errors.len() > 0 {
         for e in errors {
             eprintln!("{file}: {}:{}: {}", e.start.0, e.start.1, e.message);
@@ -50,7 +151,8 @@ pub fn process_file(file: &str) {
         return;
     }
 
-    let module = compile(semantics);
+    // shrug
+    let module = module.module.clone();
     let main_function = module.functions[module.init].clone();
 
     let mut context = Context::new(module.clone());