Embed common and core source code in the binaries, such that the binary can be run from anywhere.

Author: Ivorforce

src/cli/check.rs

@@ -25,7 +25,7 @@ pub fn run(args: &ArgMatches) -> RResult<ExitCode> {
     let start = dump_start(format!("check for {} file(s)", paths.len()).as_str());
 
     let mut runtime = Runtime::new()?;
-    runtime.repository.add("common", PathBuf::from("monoteny"));
+    runtime.add_common_repository();
 
     let mut error_count = 0;
     for path in paths {

src/cli/run.rs

@@ -19,7 +19,7 @@ pub fn run(args: &ArgMatches) -> RResult<ExitCode> {
     let input_path = args.get_one::<PathBuf>("PATH").unwrap();
 
     let mut runtime = Runtime::new()?;
-    runtime.repository.add("common", PathBuf::from("monoteny"));
+    runtime.add_common_repository();
 
     let module = runtime.load_file_as_module(input_path, module_name("main"))?;
 

src/cli/transpile.rs

@@ -8,7 +8,7 @@ use itertools::Itertools;
 use crate::error::RResult;
 use crate::interpreter::runtime::Runtime;
 use crate::program::module::{Module, module_name};
-use crate::{interpreter, transpiler};
+use crate::{interpreter, repository, transpiler};
 use crate::cli::logging::{dump_failure, dump_start, dump_success};
 use crate::transpiler::LanguageContext;
 use crate::util::file_writer::write_file_safe;
@@ -50,7 +50,7 @@ pub fn run(args: &ArgMatches) -> RResult<ExitCode> {
     };
 
     let mut runtime = Runtime::new()?;
-    runtime.repository.add("common", PathBuf::from("monoteny"));
+    runtime.add_common_repository();
 
     let module = runtime.load_file_as_module(input_path, module_name("main"))?;
 

src/error.rs

@@ -19,7 +19,7 @@ pub type RResult<V> = Result<V, Vec<RuntimeError>>;
 impl RuntimeError {
     pub fn print(&self) {
         match &self.path {
-            None => self.print_snippet(Snippet::source(&self.title)),
+            None => println!("{}", self.title),
             Some(path) => match fs::read_to_string(path) {
                 Ok(source) => self.print_snippet(
                     Snippet::source(source.as_str())

src/interpreter/builtins.rs

@@ -1,3 +1,4 @@
 pub mod primitives;
 pub mod traits;
 pub mod vm;
+pub mod modules;

src/interpreter/builtins/modules.rs

@@ -0,0 +1,26 @@
+use std::collections::HashMap;
+use crate::repository;
+
+pub fn create_core_loader() -> repository::Loader {
+    repository::Loader::Intrinsic(
+        HashMap::from([
+            (vec!["core".to_string()], include_str!("../../../monoteny/core.monoteny")),
+            (vec!["core".to_string(), "bool".to_string()], include_str!("../../../monoteny/core/bool.monoteny")),
+            (vec!["core".to_string(), "debug".to_string()], include_str!("../../../monoteny/core/debug.monoteny")),
+            (vec!["core".to_string(), "run".to_string()], include_str!("../../../monoteny/core/run.monoteny")),
+            (vec!["core".to_string(), "strings".to_string()], include_str!("../../../monoteny/core/strings.monoteny")),
+            (vec!["core".to_string(), "transpilation".to_string()], include_str!("../../../monoteny/core/transpilation.monoteny")),
+        ]),
+    )
+}
+
+pub fn create_common_loader() -> repository::Loader {
+    repository::Loader::Intrinsic(
+        HashMap::from([
+            (vec!["common".to_string()], include_str!("../../../monoteny/common.monoteny")),
+            (vec!["common".to_string(), "debug".to_string()], include_str!("../../../monoteny/common/debug.monoteny")),
+            (vec!["common".to_string(), "math".to_string()], include_str!("../../../monoteny/common/math.monoteny")),
+            (vec!["common".to_string(), "precedence".to_string()], include_str!("../../../monoteny/common/precedence.monoteny")),
+        ]),
+    )
+}

src/interpreter/runtime.rs

@@ -4,8 +4,7 @@ use std::rc::Rc;
 
 use itertools::Itertools;
 
-use crate::{ast, parser, program, resolver};
-use crate::cli::run::run;
+use crate::{ast, parser, program, repository, resolver};
 use crate::error::{RResult, RuntimeError};
 use crate::interpreter::builtins;
 use crate::interpreter::compile::compile_server::CompileServer;
@@ -65,7 +64,7 @@ impl Runtime {
         runtime.base_scope = Rc::new(runtime.make_scope()?);
 
         // Load core
-        runtime.repository.add("core", PathBuf::from("monoteny"));
+        runtime.repository.add("core", builtins::modules::create_core_loader());
         runtime.get_or_load_module(&module_name("core"))?;
 
         // Final scope can be loaded.
@@ -77,6 +76,10 @@ impl Runtime {
         Ok(runtime)
     }
 
+    pub fn add_common_repository(&mut self) {
+        self.repository.add("common", builtins::modules::create_common_loader());
+    }
+
     fn make_scope(&mut self) -> RResult<scopes::Scope<'static>> {
         let mut scope = scopes::Scope::new();
 
@@ -101,8 +104,28 @@ impl Runtime {
         }
 
         // Gotta load the module first.
-        let path = self.repository.resolve_module_path(name)?;
-        let module = self.load_file_as_module(&path, name.clone())?;
+        let Some(first_part) = name.first() else {
+            return Err(RuntimeError::error("Module name is empty...").to_array());
+        };
+
+        let Some(loader) = self.repository.entries.get(first_part) else {
+            return Err(RuntimeError::error(format!("Module not in repository: {}", first_part).as_str()).to_array());
+        };
+
+        let module = match loader {
+            repository::Loader::Path(base_path) => {
+                let path = base_path.join(PathBuf::from(format!("{}.monoteny", name.join("/").as_str())));
+                self.load_file_as_module(&path, name.clone())?
+            },
+            repository::Loader::Intrinsic(map) => {
+                let text = map.get(name)
+                    .map(ToString::to_string) // TODO Expensive copy from string literal :/
+                    .ok_or(RuntimeError::error(format!("Error loading {:?}: missing intrinsic", name).as_str()).to_array())?;
+                self.load_text_as_module(&text, name.clone())?
+                // TODO Should map error as 'in string xx', like in load_file_as_module
+            }
+        };
+
         self.source.module_by_name.insert(name.clone(), module);
         Ok(&self.source.module_by_name[name])
     }

src/interpreter/tests.rs

@@ -23,7 +23,7 @@ mod tests {
     #[test]
     fn run_expression() -> RResult<()> {
         let mut runtime = Runtime::new()?;
-        runtime.repository.add("common", PathBuf::from("monoteny"));
+        runtime.add_common_repository();
 
         let mut chunk = Chunk::new();
         chunk.push_with_u16(OpCode::LOAD16, 2);
@@ -47,7 +47,7 @@ mod tests {
 
     fn test_runs(path: &str) -> RResult<String> {
         let mut runtime = Runtime::new()?;
-        runtime.repository.add("common", PathBuf::from("monoteny"));
+        runtime.add_common_repository();
 
         let module = runtime.load_file_as_module(&PathBuf::from(path), module_name("main"))?;
 
@@ -151,7 +151,7 @@ mod tests {
     #[test]
     fn assertions() -> RResult<()> {
         let mut runtime = Runtime::new()?;
-        runtime.repository.add("common", PathBuf::from("monoteny"));
+        runtime.add_common_repository();
 
         let module = runtime.load_file_as_module(&PathBuf::from("test-code/debug/assert.monoteny"), module_name("main"))?;
 
@@ -181,7 +181,7 @@ mod tests {
     #[test]
     fn anonymous_type() -> RResult<()> {
         let mut runtime = Runtime::new()?;
-        runtime.repository.add("common", PathBuf::from("monoteny"));
+        runtime.add_common_repository();
 
         let (expression, _) = parse_expression("String")?;
         let result = runtime.evaluate_anonymous_expression(

src/repository.rs

@@ -1,11 +1,14 @@
 use std::collections::HashMap;
 use std::path::PathBuf;
-use crate::error::{RResult, RuntimeError};
-
 use crate::program::module::ModuleName;
 
+pub enum Loader {
+    Path(PathBuf),
+    Intrinsic(HashMap<ModuleName, &'static str>)
+}
+
 pub struct Repository {
-    pub entries: HashMap<String, PathBuf>,
+    pub entries: HashMap<String, Loader>,
 }
 
 impl Repository {
@@ -15,19 +18,7 @@ impl Repository {
         })
     }
 
-    pub fn add(&mut self, name: &str, path: PathBuf) {
-        self.entries.insert(name.to_string(), path);
-    }
-
-    pub fn resolve_module_path(&self, name: &ModuleName) -> RResult<PathBuf> {
-        let Some(first_part) = name.first() else {
-            return Err(RuntimeError::error("Module name is empty...").to_array());
-        };
-
-        let Some(base_path) = self.entries.get(first_part) else {
-            return Err(RuntimeError::error(format!("Module not in repository: {}", first_part).as_str()).to_array());
-        };
-
-        Ok(base_path.join(PathBuf::from(format!("{}.monoteny", name.join("/").as_str()))))
+    pub fn add(&mut self, name: &str, loader: Loader) {
+        self.entries.insert(name.to_string(), loader);
     }
 }

src/transpiler/tests.rs

@@ -13,7 +13,7 @@ mod tests {
 
     fn test_transpiles(path: &str) -> RResult<String> {
         let mut runtime = Runtime::new()?;
-        runtime.repository.add("common", PathBuf::from("monoteny"));
+        runtime.add_common_repository();
 
         let module = runtime.load_file_as_module(&PathBuf::from(path), module_name("main"))?;
         let context = transpiler::python::Context::new(&runtime);
@@ -30,7 +30,7 @@ mod tests {
     #[test]
     fn uninterpreted_hello_world() -> RResult<()> {
         let mut runtime = Runtime::new()?;
-        runtime.repository.add("common", PathBuf::from("monoteny"));
+        runtime.add_common_repository();
 
         let module = runtime.load_file_as_module(&PathBuf::from("test-code/hello_world.monoteny"), module_name("main"))?;
         let main_function = module.main_functions.iter().at_most_one().unwrap().unwrap();