Phase G: real module resolution for import statements

RandomCoder-lab · claude · RandomCoder-lab · commit 7cb4511de70c · 2026-05-13T19:54:04.000-05:00
`import core;` actually loads now. The interpreter searches for the
named module on a configurable path, parses it, and executes its
statements (registering any fn definitions in the global function
table). Idempotent re-imports via a tracked HashSet.

## Resolution

Search path (in order):
- OMC_STDLIB_PATH env var (colon-separated)
- Canonical Python OMC stdlib at Sovereign_Lattice/omninet_package/
  omnicode_stdlib/ and its std/ subdir
- Current dir, omc-stdlib/, omc-stdlib/std/ (project-local)

Per-dir naming variants: `NAME.omc`, `NAME/init.omc`, `std/NAME.omc`.

## Dispatch priority change

User-defined functions now win over built-ins. This lets `import core;`
override `is_fibonacci`, `fold`, etc. with the canonical Phase 6
implementations. Previously the built-ins shadowed user-defined
functions of the same name — matches Python OMC's behavior.

The `alias` in `import NAME as ALIAS;` is currently informational only;
imports merge into a flat function namespace.

## Verified working

  import core;
  is_fibonacci(89)         -&gt; 1 (user-defined HInt, not built-in Bool)

  import wave;
  harmonic_interfere(34,55) -&gt; 42.02 (harmonic mean, from wave.omc)

  import portal;
  safe_divide_fold(89, 0)  -&gt; 89 (canonical singularity recovery)

## Notes

The Phase 6 std/* canonical modules (`core`, `wave`, `portal`, `ica`)
from the Python OMC tree are now loadable and callable from Rust OMC.
This unblocks a large fraction of canonical .omc programs that previously
failed at the import-statement level.

The 30-file canonical compat sweep stays at 21/30 — the file that
specifically tests imports (`test_modules.omc`) uses an aspirational
`wave(...)` constructor call that doesn't exist anywhere in wave.omc,
so it remains failing despite imports working perfectly otherwise.

## Tests

111 still passing. Nothing regressed.

Co-Authored-By: Claude Opus 4.7 &lt;noreply@anthropic.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,23 @@ All notable changes to OMNIcode will be documented in this file.
 
 ## [Unreleased]
 
+### Added (Phase G: real module resolution, 2026-05-13)
+**`import core;` actually loads now.** The interpreter searches for the named module on a search path, parses it, and executes its statements (which registers any `fn` definitions in the global function table). Idempotent re-import via an `imported_modules: HashSet<String>` tracked on the interpreter.
+
+**Search path** (in order):
+1. `OMC_STDLIB_PATH` env var (colon-separated)
+2. `/home/thearchitect/Sovereign_Lattice/omninet_package/omnicode_stdlib/` — canonical Python OMC stdlib
+3. `/home/thearchitect/Sovereign_Lattice/omninet_package/omnicode_stdlib/std/` — Phase 6 modules
+4. `.`, `omc-stdlib/`, `omc-stdlib/std/` (project-local)
+
+Resolution tries `NAME.omc`, `NAME/init.omc`, and `std/NAME.omc` in each dir.
+
+**Dispatch priority change:** user-defined functions now win over built-ins. This lets `import core;` override `is_fibonacci`, `fold`, etc. with the canonical Phase 6 implementations. Previously the built-ins shadowed any user-defined function with the same name; matches Python OMC behavior.
+
+`alias` in `import NAME as ALIAS;` is currently informational — imports merge into the flat function namespace (also matching canonical Python OMC).
+
+**Verified working:** `import core; is_fibonacci(89)` returns the user-defined `1` (not the built-in `Bool(true)`). `import wave; harmonic_interfere(34, 55)` returns `42.02` from the canonical `wave.omc`. `import portal; safe_divide_fold(89, 0)` returns `89`.
+
 ### Added (Phase F: syntax + stdlib alignment for canonical compat, 2026-05-13)
 Pushing the Rust interpreter's compatibility with real-world canonical `.omc` programs from 4/N to **21 of 30 (70%)** in a sampled sweep.
 
diff --git a/omnimcode-core/src/interpreter.rs b/omnimcode-core/src/interpreter.rs
@@ -2,7 +2,7 @@
 
 use crate::ast::*;
 use crate::value::{HInt, HArray, Value, fibonacci, is_fibonacci};
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 pub struct Interpreter {
     globals: HashMap<String, Value>,
@@ -11,6 +11,8 @@ pub struct Interpreter {
     return_value: Option<Value>,
     break_flag: bool,
     continue_flag: bool,
+    /// Names of modules already imported (idempotent re-import).
+    imported_modules: HashSet<String>,
 }
 
 impl Interpreter {
@@ -22,9 +24,83 @@ impl Interpreter {
             return_value: None,
             break_flag: false,
             continue_flag: false,
+            imported_modules: HashSet::new(),
         }
     }
 
+    /// Module search path used by `import NAME;`.
+    /// Honors `OMC_STDLIB_PATH` (colon-separated), then falls back to a
+    /// small built-in list that includes the canonical Python OMC stdlib.
+    fn module_search_path() -> Vec<std::path::PathBuf> {
+        let mut paths = Vec::new();
+        if let Ok(env) = std::env::var("OMC_STDLIB_PATH") {
+            for p in env.split(':') {
+                if !p.is_empty() {
+                    paths.push(std::path::PathBuf::from(p));
+                }
+            }
+        }
+        // Canonical Python OMC stdlib (when present on this machine).
+        paths.push(std::path::PathBuf::from(
+            "/home/thearchitect/Sovereign_Lattice/omninet_package/omnicode_stdlib",
+        ));
+        paths.push(std::path::PathBuf::from(
+            "/home/thearchitect/Sovereign_Lattice/omninet_package/omnicode_stdlib/std",
+        ));
+        // Current working directory and a relative `omc-stdlib/`.
+        paths.push(std::path::PathBuf::from("."));
+        paths.push(std::path::PathBuf::from("omc-stdlib"));
+        paths.push(std::path::PathBuf::from("omc-stdlib/std"));
+        paths
+    }
+
+    fn resolve_module(name: &str) -> Option<std::path::PathBuf> {
+        // Try each search dir with a few naming variants.
+        // For `import std/core;` allow the slashed form too.
+        for dir in Self::module_search_path() {
+            for variant in [
+                format!("{}.omc", name),
+                format!("{}/init.omc", name),
+                format!("std/{}.omc", name),
+            ] {
+                let candidate = dir.join(&variant);
+                if candidate.is_file() {
+                    return Some(candidate);
+                }
+            }
+        }
+        None
+    }
+
+    fn import_module(&mut self, name: &str) -> Result<(), String> {
+        if self.imported_modules.contains(name) {
+            return Ok(()); // Already loaded.
+        }
+        let path = Self::resolve_module(name).ok_or_else(|| {
+            format!(
+                "Could not resolve module `{}` (set OMC_STDLIB_PATH or place {}.omc on the search path)",
+                name, name
+            )
+        })?;
+        let source = std::fs::read_to_string(&path)
+            .map_err(|e| format!("import {}: read failed: {}", name, e))?;
+        // Mark as imported BEFORE executing to avoid infinite recursion on
+        // cyclic imports.
+        self.imported_modules.insert(name.to_string());
+        let mut parser = crate::parser::Parser::new(&source);
+        let stmts = parser
+            .parse()
+            .map_err(|e| format!("import {}: parse error: {}", name, e))?;
+        for stmt in &stmts {
+            self.execute_stmt(stmt)?;
+            // Don't propagate `return` / `break` / `continue` past module boundary.
+            self.return_value = None;
+            self.break_flag = false;
+            self.continue_flag = false;
+        }
+        Ok(())
+    }
+
     pub fn execute(&mut self, statements: Vec<Statement>) -> Result<(), String> {
         for stmt in statements {
             self.execute_stmt(&stmt)?;
@@ -197,6 +273,11 @@ impl Interpreter {
                 self.continue_flag = true;
                 Ok(())
             }
+            Statement::Import { module, alias: _ } => {
+                // Alias is currently informational only — imports merge into a
+                // flat function namespace (matching canonical Python OMC).
+                self.import_module(module)
+            }
             _ => Ok(()),
         }
     }
@@ -421,6 +502,12 @@ impl Interpreter {
         if let Some((module, func)) = name.split_once('.') {
             return self.call_module_function(module, func, args);
         }
+        // User-defined functions win over built-ins so that `import core;`
+        // can override built-in implementations with the canonical Phase 6
+        // versions. Match Python OMC behavior.
+        if let Some((params, body)) = self.functions.get(name).cloned() {
+            return self.invoke_user_function(name, &params, &body, args);
+        }
         // Built-in functions
         match name {
             "fold" => {
@@ -1239,48 +1326,47 @@ impl Interpreter {
                     Err("arr_resonance: requires an array".to_string())
                 }
             }
-            // User-defined functions
-            _ => {
-                if let Some((params, body)) = self.functions.get(name).cloned() {
-                    let mut eval_args = Vec::new();
-                    for arg in args {
-                        eval_args.push(self.eval_expr(arg)?);
-                    }
-
-                    if params.len() != eval_args.len() {
-                        return Err(format!(
-                            "Function {} expects {} arguments, got {}",
-                            name,
-                            params.len(),
-                            eval_args.len()
-                        ));
-                    }
-
-                    // Create new scope
-                    self.locals.push(HashMap::new());
-                    for (param, arg) in params.iter().zip(eval_args) {
-                        self.set_var(param.clone(), arg);
-                    }
+            // Unknown name — already checked user-defined functions at the top.
+            _ => Err(format!("Undefined function: {}", name)),
+        }
+    }
 
-                    // Execute function body
-                    for stmt in &body {
-                        self.execute_stmt(stmt)?;
-                        if self.return_value.is_some() {
-                            break;
-                        }
-                    }
+    fn invoke_user_function(
+        &mut self,
+        name: &str,
+        params: &[String],
+        body: &[Statement],
+        args: &[Expression],
+    ) -> Result<Value, String> {
+        let mut eval_args = Vec::new();
+        for arg in args {
+            eval_args.push(self.eval_expr(arg)?);
+        }
 
-                    let result = self.return_value.take().unwrap_or(Value::Null);
+        if params.len() != eval_args.len() {
+            return Err(format!(
+                "Function {} expects {} arguments, got {}",
+                name,
+                params.len(),
+                eval_args.len()
+            ));
+        }
 
-                    // Restore scope
-                    self.locals.pop();
+        self.locals.push(HashMap::new());
+        for (param, arg) in params.iter().zip(eval_args) {
+            self.set_var(param.clone(), arg);
+        }
 
-                    Ok(result)
-                } else {
-                    Err(format!("Undefined function: {}", name))
-                }
+        for stmt in body {
+            self.execute_stmt(stmt)?;
+            if self.return_value.is_some() {
+                break;
             }
         }
+
+        let result = self.return_value.take().unwrap_or(Value::Null);
+        self.locals.pop();
+        Ok(result)
     }
 
     fn get_var(&self, name: &str) -> Option<Value> {
