02af96d | plum | pyrossh

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

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

02af96d — Peter John 2026-11-06T17:04:10+05:30

Simpler language: modules

Files changed (28) hide show

compiler/checker/src/program.rs +6 -4
compiler/checker/tests/checker/main.rs +1 -0
compiler/checker/tests/checker/modules_tests.rs +114 -0
compiler/core/src/ast.rs +6 -0
compiler/core/src/diag.rs +31 -1
compiler/core/src/lib.rs +1 -0
compiler/core/src/loader.rs +27 -0
compiler/core/src/modules.rs +376 -0
compiler/core/src/parser.rs +5 -0
compiler/core/tests/core/formatter_test.rs +9 -0
compiler/core/tests/core/loader_test.rs +30 -8
compiler/driver/src/lib.rs +1 -1
compiler/lsp/src/completion.rs +35 -2
compiler/lsp/src/main.rs +37 -2
compiler/tooling/tree-sitter-plum/grammar.js +1 -1
compiler/tooling/tree-sitter-plum/queries/plum/format.scm +3 -0
compiler/tooling/tree-sitter-plum/queries/plum/highlights.scm +5 -0
compiler/tooling/tree-sitter-plum/src/grammar.json +0 -0
compiler/tooling/tree-sitter-plum/src/node-types.json +0 -0
compiler/tooling/tree-sitter-plum/src/parser.c +0 -0
compiler/tooling/tree-sitter-plum/test/corpus/const.txt +26 -0
compiler/tooling/vscode-plum/syntaxes/plum.tmLanguage.json +14 -2
compiler/wasm-codegen/src/driver.rs +2 -1
tests/modules/constants.plum +30 -0
tests/modules/host_extern.plum +11 -0
tests/modules/mathx.plum +12 -0
tests/modules/shapes.plum +10 -0
tests/modules/two_modules.plum +34 -0

compiler/checker/src/program.rs CHANGED Viewed

@@ -84,17 +84,19 @@ pub(crate) fn checkSourceFull(source: &ast::Source) -> (CheckResult<()>, TypedIn
     (result, info)
 }
-/// The `Io` capability rules: no top-level `extern fun`, and the primitive `Io` has no constructor.
+/// The `Io` capability rules: a module-level `extern fun` takes `io: Io` first, and the
+/// primitive `Io` has no constructor.
 pub(crate) fn ioCapabilityErrors(source: &ast::Source) -> Vec<CheckError> {
     let mut errors = Vec::new();
-    // Host calls are declared only as `extern fun` methods on `primitive Io`.
+    // Host calls are `extern fun` methods on `primitive Io`, or module-level `extern fun`s
+    // whose first parameter is the capability (`io: Io`).
     for item in &source.items {
         if let ast::Item::Fn(f) = item {
-            if f.is_extern && f.type_param.is_none() {
+            if f.is_extern && f.type_param.is_none() && !ast::takesIoFirst(f) {
                 errors.push(CheckError::at(
                     f.line,
                     f.column,
-                    "host calls are declared as `extern fun` methods on `primitive Io`".to_string(),
+                    "host calls are declared as `extern fun` methods on `primitive Io`, or as a module-level `extern fun` with `io: Io` as its first parameter".to_string(),
                 ));
             }
         }

compiler/checker/tests/checker/main.rs CHANGED Viewed

@@ -4,6 +4,7 @@ mod checker_tests;
 mod closure_hint_test;
 mod diagnostic_tests;
 mod io_primitive_tests;
+mod modules_tests;
 mod explicit_generics_tests;
 mod features;
 mod fip_test;

compiler/checker/tests/checker/modules_tests.rs ADDED Viewed

@@ -0,0 +1,114 @@
+//! Modules: `import a/b` gives `b.f()` and `b.Const`; module-level constants and externs.
+//! The module files live in `tests/modules/` (`mathx` and `shapes` both define `clamp`,
+//! `twice` and `Limit`); the programs under test are written to a temp dir.
+use plum_checker::checkProgram;
+fn temp(name: &str, src: &str) -> std::path::PathBuf {
+    let dir = std::env::temp_dir().join(format!("plum_modules_{}_{}", name, std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("main.plum");
+    std::fs::write(&path, src).unwrap();
+    path
+}
+/// Loads and checks `src` (as `main.plum`, imports against the repo root); the errors are one text.
+fn run(name: &str, src: &str) -> Result<(), String> {
+    let path = temp(name, src);
+    let loaded = plum_core::loadAndMergeDiag(&path, &plum_test_support::repoRoot());
+    let _ = std::fs::remove_dir_all(path.parent().unwrap());
+    let source = loaded.map_err(|ds| ds.iter().map(|d| d.to_string()).collect::<Vec<_>>().join(" | "))?;
+    checkProgram(&source).0.map_err(|ds| ds.iter().map(|d| d.message.clone()).collect::<Vec<_>>().join(" | "))
+}
+const BOTH: &str = "import std/Int\nimport tests/modules/mathx\nimport tests/modules/shapes\n\n";
+#[test]
+fn qualified_calls_and_constants_check() {
+    run("ok", &format!("{BOTH}fun f() -> Int =\n  mathx.clamp(5) + shapes.clamp(5) + mathx.Limit + shapes.Limit\n")).unwrap();
+}
+#[test]
+fn an_unqualified_use_of_a_name_two_modules_define_is_ambiguous() {
+    let e = run("ambig", &format!("{BOTH}fun f() -> Int =\n  clamp(5)\n")).unwrap_err();
+    assert!(e.contains("'clamp' is defined in several modules (mathx, shapes)"), "{e}");
+    assert!(!e.contains('@'), "{e}");
+}
+#[test]
+fn an_unqualified_constant_two_modules_define_is_ambiguous() {
+    let e = run("ambigc", &format!("{BOTH}fun f() -> Int =\n  Limit\n")).unwrap_err();
+    assert!(e.contains("'Limit' is defined in several modules"), "{e}");
+}
+#[test]
+fn a_file_prefers_its_own_definition_of_a_shared_name() {
+    run("own", "import std/Int\nimport tests/modules/mathx\n\nfun clamp(x: Int) -> Int = x\n\nfun f() -> Int =\n  clamp(500) + mathx.clamp(500)\n").unwrap();
+}
+#[test]
+fn an_unqualified_use_resolves_to_the_one_direct_import() {
+    run("direct", "import std/Int\nimport tests/modules/mathx\n\nfun f() -> Int =\n  clamp(500)\n").unwrap();
+}
+#[test]
+fn a_module_without_the_function_is_an_error() {
+    let e = run("nofn", &format!("{BOTH}fun f() -> Int =\n  mathx.nope(1)\n")).unwrap_err();
+    assert!(e.contains("module 'mathx' has no function 'nope'"), "{e}");
+}
+#[test]
+fn a_module_without_the_constant_is_an_error() {
+    let e = run("noconst", &format!("{BOTH}fun f() -> Int =\n  mathx.Missing\n")).unwrap_err();
+    assert!(e.contains("module 'mathx' has no constant 'Missing'"), "{e}");
+}
+#[test]
+fn errors_show_the_source_name_not_the_renamed_one() {
+    let e = run("srcname", "import std/Int\nimport tests/modules/mathx\n\nfun clamp(x: Int) -> Int = true\n").unwrap_err();
+    assert!(e.contains("clamp"), "{e}");
+    assert!(!e.contains('@'), "{e}");
+}
+#[test]
+fn a_local_named_like_a_module_wins() {
+    run("local", &format!("{BOTH}fun f(mathx: Int) -> Int =\n  mathx + shapes.clamp(5)\n")).unwrap();
+}
+#[test]
+fn constants_that_read_each_other_in_a_cycle_are_an_error() {
+    let e = run("cycle", "import std/Int\n\nA = B + 1\nB = A + 1\n\nfun f() -> Int = A\n").unwrap_err();
+    assert!(e.contains("cycle"), "{e}");
+    assert!(e.contains("A -> B -> A") || e.contains("B -> A -> B"), "{e}");
+}
+#[test]
+fn a_constant_reading_itself_is_a_cycle() {
+    let e = run("self", "import std/Int\n\nA = A + 1\n\nfun f() -> Int = A\n").unwrap_err();
+    assert!(e.contains("cycle"), "{e}");
+}
+#[test]
+fn constants_declared_out_of_order_check() {
+    run("order", "import std/Int\n\nC = B + 1\nB = A + 1\nA = 1\n\nfun f() -> Int = C\n").unwrap();
+}
+#[test]
+fn an_extern_with_io_first_checks() {
+    run("ext", "import std/Io\nimport std/Float\n\nextern fun rawNowMillis(io: Io) -> Float\n\nfun f(io: Io) -> Float = rawNowMillis(io)\n").unwrap();
+}
+#[test]
+fn an_extern_without_io_first_is_rejected() {
+    let e = run("extno", "import std/Float\n\nextern fun rawNowMillis() -> Float\n").unwrap_err();
+    assert!(e.contains("with `io: Io` as its first parameter"), "{e}");
+    let e = run("extint", "import std/Int\nimport std/Float\n\nextern fun rawNowMillis(x: Int) -> Float\n").unwrap_err();
+    assert!(e.contains("with `io: Io` as its first parameter"), "{e}");
+}
+#[test]
+fn primitive_outside_std_is_rejected_for_a_built_in_and_for_an_extension() {
+    let e = run("primint", "primitive Int =\n  fun f(self) -> Byte =\n    self\n").unwrap_err();
+    assert!(e.contains("only allowed in std"), "{e}");
+    let e = run("primext", "import std/Int\n\nstruct Pt(x: Int)\n\nprimitive Pt =\n  fun g(self) -> Int = 1\n").unwrap_err();
+    assert!(e.contains("only allowed in std"), "{e}");
+}

compiler/core/src/ast.rs CHANGED Viewed

@@ -328,6 +328,12 @@ pub const BUILTIN_PRIMITIVES: [&str; 7] = ["Int", "Float", "Bool", "Str", "Byte"
 /// `primitive Io =` (std/Io.plum); extern methods are allowed nowhere else.
 pub const IO_TYPE: &str = "Io";
+/// Whether `f`'s first parameter is the `Io` capability (`io: Io`): what a module-level
+/// `extern fun` needs, and what its host import does not receive.
+pub fn takesIoFirst(f: &Fn) -> bool {
+    matches!(f.params.first(), Some(Param { ty: ParamType::Type(t), .. }) if t.name == IO_TYPE && t.generics.is_empty())
+}
 /// Separator of an associated item's mangled global name: `Float.Pi`.
 pub const MEMBER_SEP: &str = ".";

compiler/core/src/diag.rs CHANGED Viewed

@@ -32,7 +32,8 @@ pub struct Diagnostic {
 impl Diagnostic {
     pub fn new(kind: DiagKind, file: impl Into<String>, line: usize, column: usize, message: impl Into<String>) -> Self {
+        let message: String = message.into();
-        Diagnostic { file: file.into(), line, column, end_line: 0, end_column: 0, kind, message: message.into() }
+        Diagnostic { file: file.into(), line, column, end_line: 0, end_column: 0, kind, message: sourceName(&message) }
     }
     /// The same diagnostic with the end of the failing node's span (1-based, exclusive).
@@ -58,3 +59,32 @@ impl fmt::Display for Diagnostic {
         }
     }
 }
+/// `text` with the module mark of renamed definitions removed (`clamp@mathx` -> `clamp`), so
+/// messages show the names as written in the source (see `modules`).
+pub fn sourceName(text: &str) -> String {
+    if !text.contains(crate::modules::MODULE_MARK) {
+        return text.to_string();
+    }
+    let isId = |c: char| c.is_alphanumeric() || c == '_';
+    let chars: Vec<char> = text.chars().collect();
+    let mut out = String::with_capacity(text.len());
+    let mut i = 0;
+    while i < chars.len() {
+        let c = chars[i];
+        let marked = c == crate::modules::MODULE_MARK
+            && i > 0
+            && isId(chars[i - 1])
+            && chars.get(i + 1).is_some_and(|n| n.is_alphabetic() || *n == '_');
+        if marked {
+            i += 1;
+            while i < chars.len() && isId(chars[i]) {
+                i += 1;
+            }
+            continue;
+        }
+        out.push(c);
+        i += 1;
+    }
+    out
+}

compiler/core/src/lib.rs CHANGED Viewed

@@ -19,6 +19,7 @@ pub mod layout;
 pub mod loader;
 pub mod lower;
 pub mod main_result;
+pub mod modules;
 pub mod parser;
 pub mod purity;
 pub mod rename;

compiler/core/src/loader.rs CHANGED Viewed

@@ -67,12 +67,14 @@ pub fn loadAndMergeWithOverridesDiag(
         collectImport(import, lib_path, overrides, &mut visited, &mut files)?;
     }
     shadowStdTypes(&mut files, lib_path)?;
+    resolveFileModules(&mut files, lib_path)?;
     for f in &files {
         mergeItems(&f.path, &f.source, &mut items, &mut names, &mut prims, lib_path)?;
     }
     let entry_source = files.swap_remove(0).source;
     dropExtensions(&items, &mut prims)?;
+    crate::modules::orderConsts(&mut items)?;
     let mut merged = Source {
         file: entry_source.file,
         module: entry_source.module,
@@ -192,6 +194,31 @@ fn collectImport(
     Ok(())
 }
+/// Gives each file's `import a/b` the name `b` for that module's functions and constants
+/// (see `modules`), renaming the ones several files define.
+fn resolveFileModules(files: &mut [Loaded], lib_path: &Path) -> Loaded_<()> {
+    let index: HashMap<PathBuf, usize> = files.iter().enumerate().map(|(i, f)| (f.path.clone(), i)).collect();
+    let infos: Vec<crate::modules::ModuleInfo> = files
+        .iter()
+        .map(|f| crate::modules::ModuleInfo {
+            name: f.path.file_stem().map(|s| s.to_string_lossy().to_string()).unwrap_or_default(),
+            path: displayPath(&f.path),
+            imports: f
+                .source
+                .imports
+                .iter()
+                .filter_map(|imp| {
+                    let target = resolveImport(imp, lib_path).ok()?;
+                    let alias = imp.path.rsplit('/').next().unwrap_or(&imp.path).to_string();
+                    Some((alias, *index.get(&target)?))
+                })
+                .collect(),
+        })
+        .collect();
+    let mut sources: Vec<&mut Source> = files.iter_mut().map(|f| &mut f.source).collect();
+    crate::modules::resolveModules(infos, &mut sources)
+}
 fn declaredTypes(source: &Source) -> Vec<String> {
     source
         .items

compiler/core/src/modules.rs ADDED Viewed

@@ -0,0 +1,376 @@
+//! Modules. `import a/b` makes `b` a name for that file's top-level functions and
+//! constants: `b.f()`, `b.Const`. Types and enum variants stay unqualified.
+//!
+//! Two files may define the same function or constant name. Such a name is renamed per
+//! module while the files are merged (`clamp` in `mathx` becomes `clamp@mathx`), so every
+//! later pass keeps seeing plain global names and needs no change; diagnostics print the
+//! source name (see `diag::sourceName`). A name only one file defines keeps its name, and
+//! stays callable unqualified (the fallback T5 removes).
+//!
+//! Resolution of a use in file F, for a name defined in several files:
+//! - `m.f()` / `m.C` with `m` an import of F (and not a local of the function): that module's;
+//! - an unqualified use: F's own definition, else the one F imports directly, else an error.
+//!
+//! A local named like an import wins over the module (the locals of a function are its
+//! parameters and every binder in its body).
+use crate::ast::*;
+use crate::diag::{DiagKind, Diagnostic};
+use crate::rename::{renameStmts, Name};
+use crate::visit::{visitBlock, visitExpr};
+use std::collections::{HashMap, HashSet};
+/// Separates a source name from the module of a renamed definition: `clamp@mathx`.
+pub const MODULE_MARK: char = '@';
+/// What the loader knows about one file.
+pub struct ModuleInfo {
+    /// The file's stem: the name its importers use.
+    pub name: String,
+    /// For diagnostics.
+    pub path: String,
+    /// `(name, file index)` of each direct import.
+    pub imports: Vec<(String, usize)>,
+}
+/// A top-level function a module may rename: not a method, host import, export or `main`.
+fn renamable(f: &Fn) -> bool {
+    f.type_param.is_none() && !f.is_extern && !f.is_export && !f.is_test && f.name != "main"
+}
+fn isModuleConst(c: &Const) -> bool {
+    !c.name.contains(MEMBER_SEP)
+}
+struct World {
+    infos: Vec<ModuleInfo>,
+    /// Per file: every top-level fn name (any kind), and every module-level const name.
+    fns: Vec<HashSet<String>>,
+    consts: Vec<HashSet<String>>,
+    /// Names defined in two or more files (renamable fns / consts only).
+    fnCollide: HashSet<String>,
+    constCollide: HashSet<String>,
+}
+fn mangle(name: &str, module: &str) -> String {
+    format!("{name}{MODULE_MARK}{module}")
+}
+impl World {
+    fn global(&self, file: usize, name: &str, collide: &HashSet<String>) -> String {
+        if collide.contains(name) {
+            mangle(name, &self.infos[file].name)
+        } else {
+            name.to_string()
+        }
+    }
+}
+pub fn resolveModules(infos: Vec<ModuleInfo>, sources: &mut [&mut Source]) -> Result<(), Vec<Diagnostic>> {
+    let n = sources.len();
+    let mut fns = vec![HashSet::new(); n];
+    let mut consts = vec![HashSet::new(); n];
+    let mut fnCount: HashMap<String, usize> = HashMap::new();
+    let mut constCount: HashMap<String, usize> = HashMap::new();
+    for (i, s) in sources.iter().enumerate() {
+        let mut ownFns = HashSet::new();
+        let mut ownConsts = HashSet::new();
+        for item in &s.items {
+            match item {
+                Item::Fn(f) if f.type_param.is_none() => {
+                    if renamable(f) && ownFns.insert(f.name.clone()) {
+                        *fnCount.entry(f.name.clone()).or_default() += 1;
+                    }
+                    fns[i].insert(f.name.clone());
+                }
+                Item::Const(c) if isModuleConst(c) => {
+                    if ownConsts.insert(c.name.clone()) {
+                        *constCount.entry(c.name.clone()).or_default() += 1;
+                    }
+                    consts[i].insert(c.name.clone());
+                }
+                _ => {}
+            }
+        }
+    }
+    let collide = |m: &HashMap<String, usize>| -> HashSet<String> {
+        m.iter().filter(|(_, &c)| c > 1).map(|(k, _)| k.clone()).collect()
+    };
+    let world = World { fnCollide: collide(&fnCount), constCollide: collide(&constCount), infos, fns, consts };
+    // A program whose files import nothing has no `m.f()` to resolve.
+    if world.fnCollide.is_empty() && world.constCollide.is_empty() && world.infos.iter().all(|i| i.imports.is_empty()) {
+        return Ok(());
+    }
+    let mut errors = Vec::new();
+    for (i, s) in sources.iter_mut().enumerate() {
+        rewriteFile(&world, i, s, &mut errors);
+    }
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        Err(errors)
+    }
+}
+#[derive(Clone, Copy)]
+enum Kind {
+    Fn,
+    Const,
+}
+struct Cx<'a> {
+    world: &'a World,
+    file: usize,
+    aliases: HashMap<String, usize>,
+    locals: HashSet<String>,
+    errors: &'a mut Vec<Diagnostic>,
+}
+impl Cx<'_> {
+    fn error(&mut self, line: usize, column: usize, message: String) {
+        let path = self.world.infos[self.file].path.clone();
+        self.errors.push(Diagnostic::new(DiagKind::Resolution, path, line, column, message));
+    }
+    /// Which file an unqualified use of the colliding `name` means; `None` after an error.
+    fn pick(&mut self, name: &str, kind: Kind, line: usize, column: usize) -> Option<usize> {
+        let world = self.world;
+        let defines = |f: usize| match kind {
+            Kind::Fn => world.fns[f].contains(name),
+            Kind::Const => world.consts[f].contains(name),
+        };
+        if defines(self.file) {
+            return Some(self.file);
+        }
+        let direct: Vec<usize> = world.infos[self.file]
+            .imports
+            .iter()
+            .map(|(_, t)| *t)
+            .filter(|t| *t != self.file && defines(*t))
+            .collect();
+        if direct.len() == 1 {
+            return Some(direct[0]);
+        }
+        let mut owners: Vec<String> =
+            (0..world.infos.len()).filter(|f| defines(*f)).map(|f| world.infos[f].name.clone()).collect();
+        owners.sort();
+        let hint = owners.first().cloned().unwrap_or_default();
+        self.error(
+            line,
+            column,
+            format!("'{name}' is defined in several modules ({}): write {hint}.{name}", owners.join(", ")),
+        );
+        None
+    }
+    fn visit(&mut self, e: &mut Expr) {
+        let (line, column) = (e.span.startLine, e.span.startColumn);
+        let world = self.world;
+        match &mut e.kind {
+            ExprKind::Attribute(a) => {
+                let ExprKind::Var(m) = &a.object.kind else { return };
+                if self.locals.contains(m) {
+                    return;
+                }
+                let Some(&target) = self.aliases.get(m) else { return };
+                let module = m.clone();
+                let replacement = match &a.attr {
+                    AttrKind::Method(call) => {
+                        if !world.fns[target].contains(&call.name) {
+                            self.error(call.line, call.column, format!("module '{module}' has no function '{}'", call.name));
+                            return;
+                        }
+                        let mut call = call.clone();
+                        call.name = world.global(target, &call.name, &world.fnCollide);
+                        Expr::FnCall(call)
+                    }
+                    AttrKind::Field(name) => {
+                        if !world.consts[target].contains(name) {
+                            self.error(line, column, format!("module '{module}' has no constant '{name}'"));
+                            return;
+                        }
+                        Expr::TypeName(world.global(target, name, &world.constCollide))
+                    }
+                };
+                *e = replacement.at(e);
+            }
+            ExprKind::FnCall(c) if world.fnCollide.contains(&c.name) && !self.locals.contains(&c.name) => {
+                let (name, l, col) = (c.name.clone(), c.line, c.column);
+                if let Some(t) = self.pick(&name, Kind::Fn, l, col) {
+                    if let ExprKind::FnCall(c) = &mut e.kind {
+                        c.name = world.global(t, &name, &world.fnCollide);
+                    }
+                }
+            }
+            ExprKind::Var(n) if world.fnCollide.contains(n.as_str()) && !self.locals.contains(n.as_str()) => {
+                let name = n.clone();
+                if let Some(t) = self.pick(&name, Kind::Fn, line, column) {
+                    e.kind = ExprKind::Var(world.global(t, &name, &world.fnCollide));
+                }
+            }
+            ExprKind::TypeName(n) if world.constCollide.contains(n.as_str()) => {
+                let name = n.clone();
+                if let Some(t) = self.pick(&name, Kind::Const, line, column) {
+                    e.kind = ExprKind::TypeName(world.global(t, &name, &world.constCollide));
+                }
+            }
+            _ => {}
+        }
+    }
+}
+/// Every name a body declares: parameters, `:=` targets, loop binders, pattern names and
+/// closure parameters.
+fn bodyLocals(params: &[Param], stmts: &[Stmt]) -> HashSet<String> {
+    let mut out: HashSet<String> = params.iter().map(|p| p.name.clone()).collect();
+    let mut stmts = stmts.to_vec();
+    renameStmts(&mut stmts, &mut |n, kind| {
+        if matches!(kind, Name::Decl | Name::Pat) {
+            out.insert(n.clone());
+        }
+    });
+    out
+}
+/// The names a function declares anywhere in its parameters and body (see `bodyLocals`).
+pub fn fnLocals(f: &Fn) -> HashSet<String> {
+    let body = match &f.body {
+        FnBody::Block(b) => b.stmts.clone(),
+        FnBody::Expr(e) => vec![Stmt::Expr(e.clone(), 0, 0)],
+        FnBody::Extern => Vec::new(),
+    };
+    bodyLocals(&f.params, &body)
+}
+fn rewriteFile(world: &World, file: usize, source: &mut Source, errors: &mut Vec<Diagnostic>) {
+    for item in &mut source.items {
+        match item {
+            Item::Fn(f) if renamable(f) && world.fnCollide.contains(&f.name) => {
+                f.name = mangle(&f.name, &world.infos[file].name);
+            }
+            Item::Const(c) if isModuleConst(c) && world.constCollide.contains(&c.name) => {
+                c.name = mangle(&c.name, &world.infos[file].name);
+            }
+            _ => {}
+        }
+    }
+    let aliases: HashMap<String, usize> = world.infos[file]
+        .imports
+        .iter()
+        .filter(|(_, t)| *t != file)
+        .map(|(a, t)| (a.clone(), *t))
+        .collect();
+    let mut cx = Cx { world, file, aliases, locals: HashSet::new(), errors };
+    for item in &mut source.items {
+        match item {
+            Item::Fn(f) => {
+                cx.locals = fnLocals(f);
+                for p in &mut f.params {
+                    if let Some(d) = &mut p.default {
+                        visitExpr(d, &mut |e| cx.visit(e));
+                    }
+                }
+                match &mut f.body {
+                    FnBody::Block(b) => visitBlock(b, &mut |e| cx.visit(e)),
+                    FnBody::Expr(e) => visitExpr(e, &mut |e| cx.visit(e)),
+                    FnBody::Extern => {}
+                }
+            }
+            Item::Test(t) => {
+                cx.locals = bodyLocals(&[], &t.body.stmts);
+                visitBlock(&mut t.body, &mut |e| cx.visit(e));
+            }
+            Item::Const(c) => {
+                cx.locals.clear();
+                visitExpr(&mut c.value, &mut |e| cx.visit(e));
+            }
+            Item::Enum(_) => {}
+        }
+    }
+}
+/// Puts each constant after the constants its initializer reads (the slots of the
+/// constants keep their places among the other items), and rejects a cycle.
+pub fn orderConsts(items: &mut [Item]) -> Result<(), Vec<Diagnostic>> {
+    let slots: Vec<usize> = (0..items.len()).filter(|i| matches!(items[*i], Item::Const(_))).collect();
+    if slots.is_empty() {
+        return Ok(());
+    }
+    let index: HashMap<String, usize> = slots
+        .iter()
+        .enumerate()
+        .filter_map(|(k, s)| match &items[*s] {
+            Item::Const(c) => Some((c.name.clone(), k)),
+            _ => None,
+        })
+        .collect();
+    let deps: Vec<Vec<usize>> = slots
+        .iter()
+        .map(|s| {
+            let Item::Const(c) = &items[*s] else { unreachable!() };
+            let mut value = c.value.clone();
+            let mut found = Vec::new();
+            visitExpr(&mut value, &mut |e| {
+                if let ExprKind::TypeName(n) = &e.kind {
+                    if let Some(k) = index.get(n) {
+                        found.push(*k);
+                    }
+                }
+            });
+            found
+        })
+        .collect();
+    // 0 = new, 1 = on the stack, 2 = done.
+    let mut state = vec![0u8; slots.len()];
+    let mut order: Vec<usize> = Vec::new();
+    fn dfs(k: usize, deps: &[Vec<usize>], state: &mut [u8], order: &mut Vec<usize>, path: &mut Vec<usize>) -> Option<Vec<usize>> {
+        match state[k] {
+            2 => return None,
+            1 => {
+                let at = path.iter().position(|p| *p == k).unwrap_or(0);
+                let mut cycle = path[at..].to_vec();
+                cycle.push(k);
+                return Some(cycle);
+            }
+            _ => {}
+        }
+        state[k] = 1;
+        path.push(k);
+        for d in &deps[k] {
+            if let Some(c) = dfs(*d, deps, state, order, path) {
+                return Some(c);
+            }
+        }
+        path.pop();
+        state[k] = 2;
+        order.push(k);
+        None
+    }
+    for k in 0..slots.len() {
+        if let Some(cycle) = dfs(k, &deps, &mut state, &mut order, &mut Vec::new()) {
+            let name = |k: usize| match &items[slots[k]] {
+                Item::Const(c) => c.name.clone(),
+                _ => String::new(),
+            };
+            let line = match &items[slots[cycle[0]]] {
+                Item::Const(c) => c.line,
+                _ => 0,
+            };
+            let text = cycle.iter().map(|k| name(*k)).collect::<Vec<_>>().join(" -> ");
+            return Err(vec![Diagnostic::new(
+                DiagKind::Resolution,
+                "",
+                line,
+                1,
+                format!("constants refer to each other in a cycle: {text}"),
+            )]);
+        }
+    }
+    if order.iter().enumerate().all(|(i, k)| i == *k) {
+        return Ok(());
+    }
+    let taken: Vec<Item> = slots.iter().map(|s| items[*s].clone()).collect();
+    for (slot, k) in slots.iter().zip(order) {
+        items[*slot] = taken[k].clone();
+    }
+    Ok(())
+}

compiler/core/src/parser.rs CHANGED Viewed

@@ -160,6 +160,11 @@ impl<'a> AstParser<'a> {
                     items.push(Item::Fn(self.parseFn(child)));
                     topLevelOrder.push(TopLevelKind::Other);
                 }
+                // A module-level constant `ArenaW = 800.0`: a global under its own name.
+                "const" => {
+                    items.push(Item::Const(self.parseConst(child)));
+                    topLevelOrder.push(TopLevelKind::Other);
+                }
                 "test" => {
                     items.push(Item::Test(self.parseTest(child)));
                     topLevelOrder.push(TopLevelKind::Test);

compiler/core/tests/core/formatter_test.rs CHANGED Viewed

@@ -413,3 +413,12 @@ fn formatFnGenericsStayTight() {
     assert!(out.contains("fun pair[A, Elem](a: A, b: Elem) -> A = a"), "{out}");
     assert_eq!(formatSource(&out).expect("second"), out);
 }
+/// A module-level constant is its own line and keeps a blank line the source had.
+#[test]
+fn moduleLevelConstantsFormat() {
+    let input = "import std/Float\n\nArenaW = 800.0\nArenaH = 600.0\n\nArea = ArenaW * ArenaH\n\nfun f() -> Float =\n  mathx.Limit\n";
+    let out = formatSource(input).expect("formats");
+    assert_eq!(out, input);
+    assert_eq!(formatSource(&out).expect("formats twice"), out);
+}

compiler/core/tests/core/loader_test.rs CHANGED Viewed

@@ -179,18 +179,13 @@ fn unresolvableImportIsAClearError() {
 }
 #[test]
-fn duplicateTopLevelNameAcrossFilesIsAClearError() {
+fn duplicateTopLevelNameInOneFileIsAClearError() {
     let dir = TempDir::new().unwrap();
     let lib_path = dir.path().join("libs");
-    writeLibFile(
-        &lib_path,
-        "helper",
-        "module fixtures\n\nfun sharedFn(u: Unit) -> Unit =\n  u\n",
-    );
     let entry = writeLibFile(
         &lib_path,
         "main",
-        "module fixtures\n\nimport helper\n\nfun sharedFn(u: Unit) -> Unit =\n  u\n",
+        "module fixtures\n\nfun sharedFn(u: Unit) -> Unit =\n  u\n\nfun sharedFn(u: Unit) -> Unit =\n  u\n",
     );
     let result = loadAndMergeDiag(&entry, &lib_path);
@@ -203,6 +198,34 @@ fn duplicateTopLevelNameAcrossFilesIsAClearError() {
     );
 }
+#[test]
+fn sameTopLevelNameInTwoModulesIsNotACollision() {
+    let dir = TempDir::new().unwrap();
+    let lib_path = dir.path().join("libs");
+    writeLibFile(&lib_path, "helper", "module fixtures\n\nfun sharedFn(u: Unit) -> Unit =\n  u\n");
+    let entry = writeLibFile(
+        &lib_path,
+        "main",
+        "module fixtures\n\nimport helper\n\nfun sharedFn(u: Unit) -> Unit =\n  helper.sharedFn(u)\n",
+    );
+    let merged = loadAndMergeDiag(&entry, &lib_path).expect("two modules may share a function name");
+    let names: Vec<String> = merged
+        .items
+        .iter()
+        .filter_map(|i| match i {
+            plum_core::ast::Item::Fn(f) => Some(f.name.clone()),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(names.len(), 2);
+    assert_ne!(names[0], names[1], "{names:?}");
+}
+#[test]
+fn diagnosticsShowTheSourceNameOfARenamedDefinition() {
+    assert_eq!(plum_core::diag::sourceName("fn 'clamp@mathx': bad; also [email protected] and x @ y"), "fn 'clamp': bad; also a.c and x @ y");
+}
 #[test]
 fn sameMethodNameOnDifferentReceiversAcrossFilesIsNotACollision() {
     let dir = TempDir::new().unwrap();
@@ -262,7 +285,6 @@ fn removedSyntaxIsAParseError() {
         "fun f(u: Unit) -> Unit??\n  u\n",
         "fun f(u: Unit) -> Unit? =\n  u\n",
         "fun f(u: Unit) -> Unit? ! [X] =\n  u\n",
-        "Pi = 3\n",
         "extend Foo =\n  fun f() -> Unit =\n    todo\n",
     ] {
         let dir = TempDir::new().unwrap();

compiler/driver/src/lib.rs CHANGED Viewed

@@ -99,7 +99,7 @@ fn fusion(copy: &mut Source, env: &Env) -> bool {
     env.errors.borrow_mut().extend(errors);
     if env.explain {
         for n in &notes {
-            eprintln!("fusion: {n}");
+            eprintln!("fusion: {}", plum_core::diag::sourceName(n));
         }
     }
     !notes.is_empty()

compiler/lsp/src/completion.rs CHANGED Viewed

@@ -75,7 +75,7 @@ pub fn topLevelItems(source: &ast::Source) -> Vec<CompletionItem> {
         match item {
             ast::Item::Fn(f) if f.type_param.is_none() => {
                 items.push(CompletionItem {
-                    label: f.name.clone(),
+                    label: plum_core::diag::sourceName(&f.name),
                     kind: Some(CompletionItemKind::FUNCTION),
                     detail: Some("fn".to_string()),
                     ..Default::default()
@@ -99,7 +99,7 @@ pub fn topLevelItems(source: &ast::Source) -> Vec<CompletionItem> {
             }
             ast::Item::Const(c) => {
                 items.push(CompletionItem {
-                    label: c.name.clone(),
+                    label: plum_core::diag::sourceName(&c.name),
                     kind: Some(CompletionItemKind::CONSTANT),
                     ..Default::default()
                 });
@@ -160,6 +160,39 @@ pub fn staticItems(source: &ast::Source, owner: &str) -> Vec<CompletionItem> {
     items
 }
+/// Completion items for `module.`: the top-level functions and constants of the file
+/// `import .../module` names (read from its own text, so each keeps its source name).
+pub fn moduleItems(libPath: &Path, importPath: &str) -> Vec<CompletionItem> {
+    let Ok(text) = std::fs::read_to_string(libPath.join(format!("{importPath}.plum"))) else {
+        return Vec::new();
+    };
+    let mut parser = tree_sitter::Parser::new();
+    if parser.set_language(&tree_sitter_plum::LANGUAGE.into()).is_err() {
+        return Vec::new();
+    }
+    let Some(tree) = parser.parse(&text, None) else { return Vec::new() };
+    let module = plum_core::AstParser::new(&text).parseSourceRaw(tree.root_node());
+    let mut items = Vec::new();
+    for item in &module.items {
+        match item {
+            ast::Item::Fn(f) if f.type_param.is_none() && !f.is_test => items.push(CompletionItem {
+                label: f.name.clone(),
+                kind: Some(CompletionItemKind::FUNCTION),
+                detail: Some(format!("fun {importPath}.{}", f.name)),
+                ..Default::default()
+            }),
+            ast::Item::Const(c) if !c.name.contains(ast::MEMBER_SEP) => items.push(CompletionItem {
+                label: c.name.clone(),
+                kind: Some(CompletionItemKind::CONSTANT),
+                detail: Some(format!("{importPath}.{}", c.name)),
+                ..Default::default()
+            }),
+            _ => {}
+        }
+    }
+    items
+}
 /// Constructor parameters (name, type text) of struct `owner`: its own fields.
 /// Fields set by `init` are not constructor parameters. `own` is the unlowered
 /// parse of the document (header intact); `merged` is the fallback.

compiler/lsp/src/main.rs CHANGED Viewed

@@ -325,14 +325,24 @@ fn memberCompletionFor(
     cursor_line: usize,
     receiver: &str,
 ) -> Vec<CompletionItem> {
+    let tree = Backend::parseTree(text);
+    let own_source = plum_core::AstParser::new(text).parseSourceRaw(tree.root_node());
+    // `module.`: an imported module's functions and constants, unless a local has that name.
+    // Before the load: the placeholder member (`zzzzzz`) is not a function of the module.
+    let isModuleName = receiver.chars().next().is_some_and(|c| c.is_ascii_lowercase());
+    if let Some(imp) = own_source.imports.iter().filter(|_| isModuleName).find(|i| i.path.rsplit('/').next() == Some(receiver)) {
+        let isLocal = completion::enclosingFn(&own_source, cursor_line)
+            .is_some_and(|f| plum_core::modules::fnLocals(f).contains(receiver));
+        if !isLocal {
+            return completion::moduleItems(libPath, &imp.path);
+        }
+    }
     let canon = std::fs::canonicalize(path).unwrap_or(path.to_path_buf());
     let mut overrides = HashMap::new();
     overrides.insert(canon, text.to_string());
     let Ok(merged) = plum_core::loadAndMergeWithOverridesDiag(path, libPath, &overrides) else {
         return Vec::new();
     };
-    let tree = Backend::parseTree(text);
-    let own_source = plum_core::AstParser::new(text).parseSourceRaw(tree.root_node());
     // `Type.`: its associated consts and static functions.
     if receiver
         .chars()
@@ -690,6 +700,31 @@ mod tests {
         let _ = std::fs::remove_dir_all(&dir);
     }
+    /// `module.` offers the functions and constants of the imported module (source names), and a
+    /// local named like the module gets its own members instead.
+    #[test]
+    fn lsp_completes_a_module_and_shows_source_names() {
+        let dir = std::env::temp_dir().join(format!("plum-lsp-module-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join("t.plum");
+        let text = "import std/Int\nimport tests/modules/mathx\nimport tests/modules/shapes\n\nfun main() =\n  x := mathx.zzzzzz\n";
+        std::fs::write(&path, text).unwrap();
+        let labels: Vec<String> = memberCompletionFor(&path, &repoRoot(), text, 6, "mathx")
+            .into_iter()
+            .map(|i| i.label)
+            .collect();
+        for want in ["clamp", "twice", "onlyHere", "Limit", "Double"] {
+            assert!(labels.iter().any(|l| l == want), "missing {want} in {labels:?}");
+        }
+        assert!(!labels.iter().any(|l| l.contains('@')), "{labels:?}");
+        let ok = "import std/Int\nimport tests/modules/mathx\nimport tests/modules/shapes\n\nfun clamp(x: Int) -> Int = x\n\nfun main() =\n  _ := mathx.clamp(1)\n";
+        std::fs::write(&path, ok).unwrap();
+        let merged = plum_core::loadAndMergeDiag(&path, &repoRoot()).expect("loads");
+        let top: Vec<String> = completion::topLevelItems(&merged).into_iter().map(|i| i.label).collect();
+        assert!(top.iter().any(|l| l == "clamp") && !top.iter().any(|l| l.contains('@')), "{top:?}");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
     #[test]
     fn keywordsCurrent() {
         let labels: Vec<String> = completion::keywordItems()

compiler/tooling/tree-sitter-plum/grammar.js CHANGED Viewed

@@ -77,7 +77,7 @@ module.exports = grammar({
       seq(
         optional($.module),
         repeat($.import),
-        repeat(choice($.enum, $.struct, $.primitive, $.fn, $.test)),
+        repeat(choice($.enum, $.struct, $.primitive, $.fn, $.const, $.test)),
       ),
     module: ($) => seq("module", $.mod_identifier),

compiler/tooling/tree-sitter-plum/queries/plum/format.scm CHANGED Viewed

@@ -12,6 +12,9 @@
 (source
   (fn) @allow_blank_line_before)
+(source
+  (const) @allow_blank_line_before)
 (source
   (enum) @allow_blank_line_before)

compiler/tooling/tree-sitter-plum/queries/plum/highlights.scm CHANGED Viewed

@@ -12,6 +12,11 @@
   object: (primary_expression (type_identifier))
   member: (type_identifier) @constant)
+; `module.Name`: a constant of an imported module.
+(attribute
+  object: (primary_expression (var_identifier))
+  member: (type_identifier) @constant)
 ; (mod_identifier) @constant
 (type_identifier) @type
 (fn_identifier) @function

compiler/tooling/tree-sitter-plum/src/grammar.json CHANGED Viewed

Binary file

compiler/tooling/tree-sitter-plum/src/node-types.json CHANGED Viewed

Binary file

compiler/tooling/tree-sitter-plum/src/parser.c CHANGED Viewed

Binary file

compiler/tooling/tree-sitter-plum/test/corpus/const.txt CHANGED Viewed

@@ -185,3 +185,29 @@ fun main() =
                   (type_identifier)))
               (primary_expression
                 (float)))))))))
+================================================================================
+module-level const
+================================================================================
+ArenaW = 800.0
+fun f() -> Float =
+  ArenaW
+--------------------------------------------------------------------------------
+(source
+  (const
+    (type_identifier)
+    (expression
+      (primary_expression
+        (float))))
+  (fn
+    (fn_identifier)
+    (type
+      (type_identifier))
+    (body
+      (expression
+        (primary_expression
+          (type_identifier))))))

compiler/tooling/vscode-plum/syntaxes/plum.tmLanguage.json CHANGED Viewed

@@ -102,8 +102,20 @@
           }
         },
         {
+          "comment": "module constant access: module.Name",
+          "match": "\\b([a-z_][A-Za-z0-9_]*)\\.([A-Z][A-Za-z0-9]+)\\b",
+          "captures": {
+            "1": {
+              "name": "variable.other.plum"
+            },
+            "2": {
+              "name": "constant.other.plum"
+            }
+          }
+        },
+        {
-          "comment": "constant declarations: Name = expr",
+          "comment": "constant declarations: Name = expr (module level or in a type body)",
-          "match": "^\\s+([A-Z][A-Za-z0-9]+)(?=\\s*=(?!=))",
+          "match": "^\\s*([A-Z][A-Za-z0-9]+)(?=\\s*=(?!=))",
           "captures": {
             "1": {
               "name": "constant.other.plum"

compiler/wasm-codegen/src/driver.rs CHANGED Viewed

@@ -391,7 +391,8 @@ impl<'a> Setup<'a> {
             }
             // An extern METHOD (of the primitive `Io`) takes its receiver as the first
             // wrapper param; the host import has no receiver.
+            // A module-level extern's `io: Io` is the capability too: not passed to the host.
-            let skip = usize::from(f.type_param.is_some() && f.has_self);
+            let skip = usize::from((f.type_param.is_some() && f.has_self) || (f.type_param.is_none() && ast::takesIoFirst(f)));
             let key = if f.type_param.is_some() { fnKey(f) } else { f.name.clone() };
             if f.type_param.is_none() {
                 known_fns.insert(f.name.clone());

tests/modules/constants.plum ADDED Viewed

@@ -0,0 +1,30 @@
+import std/Int
+import std/Float
+import std/Str
+import std/List
+# Module-level constants: any pure expression, read in dependency order.
+Third = Second * 3
+Second = First + 1
+First = 4
+ArenaW = 800.0
+ArenaArea = ArenaW * ArenaH
+ArenaH = 600.0
+Greeting = "hello " + "there"
+Boxes = [Second, Third]
+test "constants read each other in dependency order"
+  assert First == 4
+  assert Second == 5
+  assert Third == 15
+test "a float constant"
+  assert ArenaW == 800.0
+  assert ArenaArea == 480000.0
+test "a string constant"
+  assert Greeting == "hello there"
+test "a constant holding a list"
+  assert Boxes.length() == 2

tests/modules/host_extern.plum ADDED Viewed

@@ -0,0 +1,11 @@
+import std/Io
+import std/Float
+# A module-level `extern fun` takes `io: Io` first and binds to the host by name,
+# the same route the `extern fun` methods of `Io` use.
+extern fun rawNowMillis(io: Io) -> Float
+fun nowIsLater(io: Io) -> Bool = rawNowMillis(io) > 1000.0
+test "a module-level extern calls the host"
+  assert nowIsLater(io)

tests/modules/mathx.plum ADDED Viewed

@@ -0,0 +1,12 @@
+import std/Int
+# A module other files import as `mathx`. Its `clamp` and `Limit` are also defined by `shapes`.
+Limit = 10
+Double = Limit * 2
+fun clamp(x: Int) -> Int = if x > Limit then Limit else x
+fun twice(x: Int) -> Int = clamp(x) * 2
+fun onlyHere(x: Int) -> Int = x + 1

tests/modules/shapes.plum ADDED Viewed

@@ -0,0 +1,10 @@
+import std/Int
+# The second module that defines `clamp` and `Limit`.
+Limit = 100
+Doubled = Limit + Limit
+fun clamp(x: Int) -> Int = if x > Limit then Limit else x
+fun twice(x: Int) -> Int = clamp(x) * 2

tests/modules/two_modules.plum ADDED Viewed

@@ -0,0 +1,34 @@
+import std/Int
+import tests/modules/mathx
+import tests/modules/shapes
+# Two modules define `clamp`, `twice` and `Limit`: each is reached by its module name.
+fun viaFunctionValue(f: fn(Int) -> Int, x: Int) -> Int = f(x)
+test "the same function name in two modules"
+  assert mathx.clamp(50) == 10
+  assert shapes.clamp(50) == 50
+  assert shapes.clamp(500) == 100
+test "a function calls its own module's colliding helper"
+  assert mathx.twice(50) == 20
+  assert shapes.twice(50) == 100
+test "the same constant name in two modules"
+  assert mathx.Limit == 10
+  assert shapes.Limit == 100
+test "a constant may read another constant of its module"
+  assert mathx.Double == 20
+  assert shapes.Doubled == 200
+test "a name only one module defines is reached through its module"
+  assert mathx.onlyHere(1) == 2
+test "a qualified function can be passed as a value after a call"
+  assert viaFunctionValue(|x: Int| mathx.clamp(x), 99) == 10
+test "a local named like a module wins over the module"
+  mathx := |x: Int| x + 1000
+  assert mathx(1) == 1001