8a7f6ad | plum

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

8a7f6ad — Peter John 2026-07-23T21:23:15+05:30

feat(plum-core): add load_and_merge cross-file import loader

Files changed (5) hide show

Cargo.lock +20 -0
plum-core/Cargo.toml +3 -0
plum-core/src/lib.rs +2 -0
plum-core/src/loader.rs +114 -0
plum-core/tests/loader_test.rs +133 -0

Cargo.lock CHANGED Viewed

@@ -532,6 +532,12 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+[[package]]
+name = "fastrand"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.9"
@@ -1027,6 +1033,7 @@ dependencies = [
 name = "plum-core"
 version = "0.1.0"
 dependencies = [
+ "tempfile",
  "topiary-core",
  "topiary-tree-sitter-facade",
  "tree-sitter",
@@ -1408,6 +1415,19 @@ version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.3",
+ "once_cell",
+ "rustix 1.1.4",
+ "windows-sys 0.61.2",
+]
 [[package]]
 name = "termcolor"
 version = "1.4.1"

plum-core/Cargo.toml CHANGED Viewed

@@ -8,3 +8,6 @@ tree-sitter = "0.26"
 tree-sitter-plum = { path = "../tooling/tree-sitter-plum" }
 topiary-core = "0.7.3"
 topiary-tree-sitter-facade = "0.7.3"
+[dev-dependencies]
+tempfile = "3"

plum-core/src/lib.rs CHANGED Viewed

@@ -1,6 +1,8 @@
 pub mod ast;
 pub mod parser;
 pub mod formatter;
+pub mod loader;
 pub use formatter::{format_source, format_source_with_opts, FormatterError};
 pub use parser::AstParser;
+pub use loader::load_and_merge;

plum-core/src/loader.rs ADDED Viewed

@@ -0,0 +1,114 @@
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+use crate::ast::{Import, Item, Source};
+use crate::parser::AstParser;
+/// Resolves `entry`'s `import` statements (transitively, and tolerating
+/// diamond imports and cycles) against `lib_path`, and merges every reachable
+/// file's top-level items into a single `Source`. The result's `module` and
+/// `imports` fields are `entry`'s own (imported files' `module`/`imports`
+/// fields are not otherwise used once their `items` have been merged in) —
+/// only `items` accumulates across files.
+///
+/// `import "std/option"` resolves to `<lib_path>/std/option.plum`.
+pub fn load_and_merge(entry: &Path, lib_path: &Path) -> Result<Source, String> {
+    let entry_canon = std::fs::canonicalize(entry)
+        .map_err(|e| format!("cannot read entry file '{}': {}", entry.display(), e))?;
+    let entry_source = parse_file(&entry_canon)?;
+    let mut visited: HashSet<PathBuf> = HashSet::new();
+    let mut items: Vec<Item> = Vec::new();
+    let mut names: HashMap<String, PathBuf> = HashMap::new();
+    visited.insert(entry_canon.clone());
+    merge_items(&entry_canon, &entry_source, &mut items, &mut names)?;
+    for import in &entry_source.imports {
+        load_import(import, lib_path, &mut visited, &mut items, &mut names)?;
+    }
+    Ok(Source {
+        module: entry_source.module,
+        imports: entry_source.imports,
+        items,
+    })
+}
+fn load_import(
+    import: &Import,
+    lib_path: &Path,
+    visited: &mut HashSet<PathBuf>,
+    items: &mut Vec<Item>,
+    names: &mut HashMap<String, PathBuf>,
+) -> Result<(), String> {
+    let target = lib_path.join(format!("{}.plum", import.path));
+    let target_canon = std::fs::canonicalize(&target)
+        .map_err(|_| format!("import '{}': no such file '{}'", import.path, target.display()))?;
+    if !visited.insert(target_canon.clone()) {
+        // Already loaded — a diamond import or a cycle. Either way, its items
+        // are already in `items`; nothing more to do.
+        return Ok(());
+    }
+    let source = parse_file(&target_canon)?;
+    merge_items(&target_canon, &source, items, names)?;
+    for nested in &source.imports {
+        load_import(nested, lib_path, visited, items, names)?;
+    }
+    Ok(())
+}
+fn parse_file(path: &Path) -> Result<Source, String> {
+    let text = std::fs::read_to_string(path)
+        .map_err(|e| format!("cannot read '{}': {}", path.display(), e))?;
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(&tree_sitter_plum::LANGUAGE.into())
+        .map_err(|e| format!("language error: {}", e))?;
+    let tree = parser
+        .parse(&text, None)
+        .ok_or_else(|| format!("parse failed for '{}'", path.display()))?;
+    let ap = AstParser::new(&text);
+    Ok(ap.parse_source(tree.root_node()))
+}
+fn merge_items(
+    file: &Path,
+    source: &Source,
+    items: &mut Vec<Item>,
+    names: &mut HashMap<String, PathBuf>,
+) -> Result<(), String> {
+    for item in &source.items {
+        let key = item_name_key(item);
+        if let Some(existing_file) = names.get(&key) {
+            return Err(format!(
+                "duplicate declaration '{}': declared in both '{}' and '{}'",
+                key,
+                existing_file.display(),
+                file.display()
+            ));
+        }
+        names.insert(key, file.to_path_buf());
+        items.push(item.clone());
+    }
+    Ok(())
+}
+/// A collision key that mirrors `plum-checker`'s own separation of
+/// namespaces: methods are keyed by `(receiver, name)` (so `length<Cat>` and
+/// `length<Box>` never collide, exactly like `plum_checker::MethodEnv`),
+/// while classes/traits/enums/consts/free-functions are each their own
+/// flat, kind-qualified namespace.
+fn item_name_key(item: &Item) -> String {
+    match item {
+        Item::Class(c) => format!("class::{}", c.name),
+        Item::Trait(t) => format!("trait::{}", t.name),
+        Item::Enum(e) => format!("enum::{}", e.name),
+        Item::Const(c) => format!("const::{}", c.name),
+        Item::Fn(f) => match &f.type_param {
+            Some(recv) => format!("method::{}::{}", recv, f.name),
+            None => format!("fn::{}", f.name),
+        },
+    }
+}

plum-core/tests/loader_test.rs ADDED Viewed

@@ -0,0 +1,133 @@
+use plum_core::load_and_merge;
+use std::fs;
+use tempfile::TempDir;
+/// Writes `name` (without a directory prefix — always placed directly under
+/// the temp dir's `lib_path` subdirectory) with `contents`, creating parent
+/// directories as needed (so `"std/option"` works).
+fn write_lib_file(lib_path: &std::path::Path, name: &str, contents: &str) -> std::path::PathBuf {
+    let path = lib_path.join(format!("{}.plum", name));
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    fs::write(&path, contents).unwrap();
+    path
+}
+#[test]
+fn import_sees_imported_declarations() {
+    let dir = TempDir::new().unwrap();
+    let lib_path = dir.path().join("libs");
+    write_lib_file(&lib_path, "helper", "module fixtures\n\nhelperFn() -> Int =\n  42\n");
+    let entry = write_lib_file(&lib_path, "main", "module fixtures\n\nimport helper\n\nmain() -> Int =\n  helperFn()\n");
+    let merged = load_and_merge(&entry, &lib_path).expect("load_and_merge failed");
+    let names: Vec<&str> = merged.items.iter().filter_map(|i| match i {
+        plum_core::ast::Item::Fn(f) => Some(f.name.as_str()),
+        _ => None,
+    }).collect();
+    assert!(names.contains(&"main"), "expected 'main' in merged items, got {:?}", names);
+    assert!(names.contains(&"helperFn"), "expected 'helperFn' in merged items, got {:?}", names);
+}
+#[test]
+fn transitive_import_surfaces_grandchild_declarations() {
+    let dir = TempDir::new().unwrap();
+    let lib_path = dir.path().join("libs");
+    write_lib_file(&lib_path, "c", "module fixtures\n\ncFn() -> Int =\n  3\n");
+    write_lib_file(&lib_path, "b", "module fixtures\n\nimport c\n\nbFn() -> Int =\n  cFn()\n");
+    let entry = write_lib_file(&lib_path, "a", "module fixtures\n\nimport b\n\nmain() -> Int =\n  bFn()\n");
+    let merged = load_and_merge(&entry, &lib_path).expect("load_and_merge failed");
+    let names: Vec<&str> = merged.items.iter().filter_map(|i| match i {
+        plum_core::ast::Item::Fn(f) => Some(f.name.as_str()),
+        _ => None,
+    }).collect();
+    assert!(names.contains(&"cFn"), "expected transitively-imported 'cFn', got {:?}", names);
+}
+#[test]
+fn diamond_import_includes_shared_dependency_once() {
+    let dir = TempDir::new().unwrap();
+    let lib_path = dir.path().join("libs");
+    write_lib_file(&lib_path, "d", "module fixtures\n\ndFn() -> Int =\n  4\n");
+    write_lib_file(&lib_path, "b", "module fixtures\n\nimport d\n\nbFn() -> Int =\n  dFn()\n");
+    write_lib_file(&lib_path, "c", "module fixtures\n\nimport d\n\ncFn() -> Int =\n  dFn()\n");
+    let entry = write_lib_file(&lib_path, "a", "module fixtures\n\nimport b\nimport c\n\nmain() -> Int =\n  bFn() + cFn()\n");
+    let merged = load_and_merge(&entry, &lib_path).expect("load_and_merge failed");
+    let d_count = merged.items.iter().filter(|i| matches!(i, plum_core::ast::Item::Fn(f) if f.name == "dFn")).count();
+    assert_eq!(d_count, 1, "expected 'dFn' exactly once in a diamond import, got {}", d_count);
+}
+#[test]
+fn import_cycle_resolves_without_hanging_or_erroring() {
+    let dir = TempDir::new().unwrap();
+    let lib_path = dir.path().join("libs");
+    write_lib_file(&lib_path, "b", "module fixtures\n\nimport a\n\nbFn() -> Int =\n  1\n");
+    let entry = write_lib_file(&lib_path, "a", "module fixtures\n\nimport b\n\nmain() -> Int =\n  bFn()\n");
+    let merged = load_and_merge(&entry, &lib_path).expect("import cycle should resolve, not error");
+    let names: Vec<&str> = merged.items.iter().filter_map(|i| match i {
+        plum_core::ast::Item::Fn(f) => Some(f.name.as_str()),
+        _ => None,
+    }).collect();
+    assert!(names.contains(&"main"));
+    assert!(names.contains(&"bFn"));
+}
+#[test]
+fn unresolvable_import_is_a_clear_error() {
+    let dir = TempDir::new().unwrap();
+    let lib_path = dir.path().join("libs");
+    let entry = write_lib_file(&lib_path, "main", "module fixtures\n\nimport does_not_exist\n\nmain() -> Int =\n  0\n");
+    let result = load_and_merge(&entry, &lib_path);
+    assert!(result.is_err());
+    let msg = result.unwrap_err();
+    assert!(msg.contains("does_not_exist"), "expected error to name the missing import, got: {}", msg);
+}
+#[test]
+fn duplicate_top_level_name_across_files_is_a_clear_error() {
+    let dir = TempDir::new().unwrap();
+    let lib_path = dir.path().join("libs");
+    write_lib_file(&lib_path, "helper", "module fixtures\n\nsharedFn() -> Int =\n  1\n");
+    let entry = write_lib_file(&lib_path, "main", "module fixtures\n\nimport helper\n\nsharedFn() -> Int =\n  2\n");
+    let result = load_and_merge(&entry, &lib_path);
+    assert!(result.is_err());
+    let msg = result.unwrap_err();
+    assert!(msg.contains("sharedFn"), "expected error to name the duplicate 'sharedFn', got: {}", msg);
+}
+#[test]
+fn same_method_name_on_different_receivers_across_files_is_not_a_collision() {
+    let dir = TempDir::new().unwrap();
+    let lib_path = dir.path().join("libs");
+    write_lib_file(&lib_path, "cat", "\
+module fixtures
+type Cat =
+  age: Int
+length<Cat>(self) -> Int =
+  self.age
+");
+    let entry = write_lib_file(&lib_path, "main", "\
+module fixtures
+import cat
+type Box =
+  items: Int
+length<Box>(self) -> Int =
+  self.items
+main() -> Int =
+  0
+");
+    let merged = load_and_merge(&entry, &lib_path).expect("same method name on different receivers should not collide");
+    let method_count = merged.items.iter().filter(|i| matches!(i, plum_core::ast::Item::Fn(f) if f.name == "length")).count();
+    assert_eq!(method_count, 2, "expected both 'length' methods to survive the merge, got {}", method_count);
+}