From 093485072f4e798059a27806af913ed9f069661d Mon Sep 17 00:00:00 2001
From: Raphael Amorim <rapha850@gmail.com>
Date: Fri, 24 Jul 2026 23:54:31 +0200
Subject: [PATCH] externs and consts resolve through import handles

---
 crates/jam-sema/src/astgen.rs            | 33 ++++++++++++++++++++++--
 tests/unit/mod_handle_access.jam         |  5 ++++
 tests/unit/test_import_handle_access.jam | 18 +++++++++++++
 3 files changed, 54 insertions(+), 2 deletions(-)
 create mode 100644 tests/unit/mod_handle_access.jam
 create mode 100644 tests/unit/test_import_handle_access.jam

diff --git a/crates/jam-sema/src/astgen.rs b/crates/jam-sema/src/astgen.rs
index 581703e..e6a0383 100644
--- a/crates/jam-sema/src/astgen.rs
+++ b/crates/jam-sema/src/astgen.rs
@@ -4808,9 +4808,18 @@ fn astgen_dotted_call(
     }
 
     // 2. Prefix as an IMPORT HANDLE (`const lib = import("m"); lib.fn()`) -> the
-    // free function `m.fn`.
+    // free function `m.fn`. Externs/exports register under their bare C name
+    // only (module_path stays empty so the symbol isn't mangled), so a handle
+    // spelling like `objc.objc_getClass` falls back to the bare lookup.
     if let Some(module) = gctx.ctx.import_handle_module(prefix)
-        && let Some(method) = gctx.ctx.get_function_ast(&format!("{module}.{suffix}"))
+        && let Some(method) = gctx
+            .ctx
+            .get_function_ast(&format!("{module}.{suffix}"))
+            .or_else(|| {
+                gctx.ctx
+                    .get_function_ast(suffix)
+                    .filter(|f| f.is_extern || f.is_export)
+            })
     {
         // Privacy: a non-`pub` function reached through a module handle is not
         // exported. `extern`/`export` libc bare names stay accessible.
@@ -6999,6 +7008,26 @@ fn astgen_member_access(gctx: &mut AstGenCtx, n: &AstNode) -> Result<JirRef, Str
                 ));
             }
         }
+        // Module const through an import handle (`metal.StorageModeShared`):
+        // inline it exactly like a bare module-const reference would.
+        if !gctx.locals.contains_key(&base_name)
+            && let Some(module) = gctx.ctx.import_handle_module(&base_name)
+        {
+            if let Some(mc) = gctx.ctx.get_module_const(&format!("{module}.{member}")) {
+                if mc.is_comp {
+                    let v = gctx.ctx.fold_comptime_expr(mc.init_expr);
+                    if !v.is_none() {
+                        return materialize_comptime_value(
+                            gctx,
+                            &v,
+                            mc.declared_type,
+                            &format!("comp const `{member}`"),
+                        );
+                    }
+                }
+                return astgen_expr(gctx, mc.init_expr, mc.declared_type);
+            }
+        }
     }
 
     // Handle-qualified enum-variant reference (`a.Status.Ok`): the base is itself
diff --git a/tests/unit/mod_handle_access.jam b/tests/unit/mod_handle_access.jam
new file mode 100644
index 0000000..28bbc61
--- /dev/null
+++ b/tests/unit/mod_handle_access.jam
@@ -0,0 +1,5 @@
+// Helper module for test_import_handle_access.jam.
+pub extern fn labs(x: i64) i64;
+pub const MAGIC: u64 = 42;
+pub const WIDE: u64 = 70000;
+pub fn double(x: u64) u64 { return x * 2; }
diff --git a/tests/unit/test_import_handle_access.jam b/tests/unit/test_import_handle_access.jam
new file mode 100644
index 0000000..c619a4d
--- /dev/null
+++ b/tests/unit/test_import_handle_access.jam
@@ -0,0 +1,18 @@
+// Symbols reached through an import handle: pub fns always worked;
+// externs (registered under their bare C name) and module consts used
+// to miss and error.
+const { assert } = import("test");
+const h = import("mod_handle_access");
+
+tfn externThroughHandle() {
+    assert(h.labs(-4) as i32, 4);
+}
+
+tfn constThroughHandle() {
+    assert(h.MAGIC as i32, 42);
+    assert((h.WIDE == 70000) as u8, 1);
+}
+
+tfn fnThroughHandle() {
+    assert(h.double(21) as i32, 42);
+}
-- 
knotmirror 0.0.1