rsscript: fix cross-file associated consts and module-prefix collisions

Two namespace-isolation bugs found in review:

1. Cross-file associated constants (`Device.DEFAULT` declared in one module,
   read from another via `use device.Device`) produced RS0026 — the per-file
   associated-const desugar only fires when the dotted const is in the same
   parsed file, and isolation then left `Device.DEFAULT` as a field access.
   Isolation now recognizes `Type.CONST` access: when the base is a module-scoped
   type whose module declares the flattened constant, it resolves the access to
   the module-qualified const symbol. Constants are mangled through `mangle_value`
   (upper-cased) so the declaration and references agree with the backend's
   SCREAMING_SNAKE const lowering.

2. Module-prefix collisions: `module a.b` and `module a_b` both joined to the
   prefix `a_b`. Prefixes are now built injectively (each segment's underscores
   are doubled before joining with a single underscore), so `a.b` -> `a_b` and
   `a_b` -> `a__b` stay distinct.

Also allow non_camel_case_types / non_upper_case_globals in generated crates
(module-isolated symbols carry a lowercase module prefix).

Tests: cross-file associated-const lowering, dotted-vs-underscored module paths,
and module_prefix injectivity unit tests. Full cargo test -p rsscript green;
clippy clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Haofei

crates/rsscript/src/rust_lower/lowerer.rs

@@ -137,7 +137,11 @@ impl<'a> RustLowerer<'a> {
         out.push_str(
             "// Runtime hooks are intentionally explicit while Rust lowering is stabilizing.\n",
         );
-        out.push_str("#![allow(dead_code, non_snake_case)]\n");
+        // Module-isolated symbols carry a lowercase module prefix (`device__Device`,
+        // `helpers__count`), so the camel/snake/upper-case lints don't apply.
+        out.push_str(
+            "#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]\n",
+        );
         let feature_names = lowered_feature_names(&self.program.features);
         if feature_names.is_empty() {
             out.push_str("// RSScript features: <none>\n");

crates/rsscript/src/syntax/module_isolation.rs

@@ -23,6 +23,27 @@ use super::ast::{
 /// the boundary readable in diagnostics and generated Rust (`a_b__name`).
 const MODULE_SEP: &str = "__";
 
+/// Encode a dotted module path as a single Rust-identifier prefix, injectively:
+/// each segment's own underscores are doubled before segments are joined with a
+/// single underscore, so distinct paths (`a.b` vs `a_b`) never collide.
+fn module_prefix(segments: &[String]) -> String {
+    segments
+        .iter()
+        .map(|segment| segment.replace('_', "__"))
+        .collect::<Vec<_>>()
+        .join("_")
+}
+
+/// The module prefix for a dotted namespace string (`a.b` -> `a_b`).
+fn module_prefix_from_dotted(namespace: &str) -> String {
+    module_prefix(
+        &namespace
+            .split('.')
+            .map(str::to_string)
+            .collect::<Vec<_>>(),
+    )
+}
+
 /// Rewrite a program so each `module`-scoped symbol becomes globally unique.
 pub fn isolate_module_namespaces(program: &mut Program) {
     let file_module = collect_file_modules(program);
@@ -42,7 +63,7 @@ fn collect_file_modules(program: &Program) -> HashMap<String, String> {
         if let Item::Module(module) = item {
             file_module
                 .entry(module.span.file.clone())
-                .or_insert_with(|| module.path.join("_"));
+                .or_insert_with(|| module_prefix(&module.path));
         }
     }
     file_module
@@ -57,6 +78,10 @@ struct Resolver {
     /// module prefix -> the type names it declares (for `Type.method` / `Type.X`
     /// namespace resolution).
     module_types: HashMap<String, HashSet<String>>,
+    /// module prefix -> the constant names it declares. Constants lower to
+    /// `SCREAMING_SNAKE_CASE`, so their mangled symbol is upper-cased to stay
+    /// consistent between declaration and reference.
+    module_consts: HashMap<String, HashSet<String>>,
     /// file -> (imported bare name -> module prefix it was imported from).
     file_imports: HashMap<String, HashMap<String, String>>,
 }
@@ -65,6 +90,7 @@ impl Resolver {
     fn build(program: &Program, file_module: &HashMap<String, String>) -> Self {
         let mut module_defs: HashMap<String, HashSet<String>> = HashMap::new();
         let mut module_types: HashMap<String, HashSet<String>> = HashMap::new();
+        let mut module_consts: HashMap<String, HashSet<String>> = HashMap::new();
         let mut file_imports: HashMap<String, HashMap<String, String>> = HashMap::new();
 
         for item in &program.items {
@@ -92,6 +118,10 @@ impl Resolver {
                             .entry(prefix.clone())
                             .or_default()
                             .insert(decl.name.clone());
+                        module_consts
+                            .entry(prefix.clone())
+                            .or_default()
+                            .insert(decl.name.clone());
                     }
                 }
                 Item::Type(decl) => {
@@ -127,7 +157,7 @@ impl Resolver {
                 Item::Use(decl) => {
                     if decl.path.len() >= 2 {
                         let name = decl.path[decl.path.len() - 1].clone();
-                        let import_prefix = decl.path[..decl.path.len() - 1].join("_");
+                        let import_prefix = module_prefix(&decl.path[..decl.path.len() - 1]);
                         file_imports
                             .entry(decl.span.file.clone())
                             .or_default()
@@ -142,10 +172,27 @@ impl Resolver {
             file_module: file_module.clone(),
             module_defs,
             module_types,
+            module_consts,
             file_imports,
         }
     }
 
+    /// Build the mangled value symbol for `name` declared in module `prefix`,
+    /// upper-casing constants so the symbol matches the Rust backend's
+    /// `SCREAMING_SNAKE_CASE` const lowering at both declaration and reference.
+    fn mangle_value(&self, prefix: &str, name: &str) -> String {
+        let mangled = format!("{prefix}{MODULE_SEP}{name}");
+        if self
+            .module_consts
+            .get(prefix)
+            .is_some_and(|consts| consts.contains(name))
+        {
+            mangled.to_uppercase()
+        } else {
+            mangled
+        }
+    }
+
     /// The mangled name for a bare value/type symbol `name` referenced from
     /// `file`, or `None` to leave it unchanged (root symbol, builtin, external,
     /// or unresolved).
@@ -157,7 +204,7 @@ impl Resolver {
                 .get(prefix)
                 .is_some_and(|names| names.contains(name))
         {
-            return Some(format!("{prefix}{MODULE_SEP}{name}"));
+            return Some(self.mangle_value(prefix, name));
         }
         // Otherwise a `use module.name` import that names a known module symbol.
         if let Some(import_prefix) = self
@@ -169,36 +216,43 @@ impl Resolver {
                 .get(import_prefix)
                 .is_some_and(|names| names.contains(name))
         {
-            return Some(format!("{import_prefix}{MODULE_SEP}{name}"));
+            return Some(self.mangle_value(import_prefix, name));
         }
         None
     }
 
-    /// Resolve a `Type.` namespace (for `Type.method` / `Type.CONST`): if the
-    /// namespace names a module-scoped type, return its mangled type name.
-    fn resolve_type_namespace(&self, file: &str, namespace: &str) -> Option<String> {
+    /// The module prefix that owns type `name` as seen from `file` (own module,
+    /// then `use` import), or `None` if it is not a module-scoped type.
+    fn resolve_type_module(&self, file: &str, name: &str) -> Option<String> {
         if let Some(prefix) = self.file_module.get(file)
             && self
                 .module_types
                 .get(prefix)
-                .is_some_and(|types| types.contains(namespace))
+                .is_some_and(|types| types.contains(name))
         {
-            return Some(format!("{prefix}{MODULE_SEP}{namespace}"));
+            return Some(prefix.clone());
         }
         if let Some(import_prefix) = self
             .file_imports
             .get(file)
-            .and_then(|imports| imports.get(namespace))
+            .and_then(|imports| imports.get(name))
             && self
                 .module_types
                 .get(import_prefix)
-                .is_some_and(|types| types.contains(namespace))
+                .is_some_and(|types| types.contains(name))
         {
-            return Some(format!("{import_prefix}{MODULE_SEP}{namespace}"));
+            return Some(import_prefix.clone());
         }
         None
     }
 
+    /// Resolve a `Type.` namespace (for `Type.method` / `Type.CONST`): if the
+    /// namespace names a module-scoped type, return its mangled type name.
+    fn resolve_type_namespace(&self, file: &str, namespace: &str) -> Option<String> {
+        self.resolve_type_module(file, namespace)
+            .map(|prefix| format!("{prefix}{MODULE_SEP}{namespace}"))
+    }
+
     fn rewrite(&self, program: &mut Program) {
         for item in &mut program.items {
             let Some(file) = item_file(item).map(str::to_string) else {
@@ -243,8 +297,13 @@ impl Resolver {
     }
 
     fn rewrite_const(&self, decl: &mut ConstDecl, file: &str, in_module: bool) {
-        if in_module {
-            decl.name = self.mangle_decl_name(file, &decl.name);
+        // Constants are mangled through `mangle_value` (upper-cased) so the
+        // declaration matches references and the backend's const lowering.
+        if in_module
+            && !decl.name.contains('.')
+            && let Some(prefix) = self.file_module.get(file)
+        {
+            decl.name = self.mangle_value(prefix, &decl.name);
         }
         if let Some(ty) = &mut decl.type_annotation {
             self.rewrite_type(ty, file);
@@ -472,7 +531,28 @@ impl Resolver {
                     self.rewrite_expr(&mut arg.value, file, scope);
                 }
             }
-            Expr::Field { base, .. } => self.rewrite_expr(base, file, scope),
+            Expr::Field { base, name, span } => {
+                // `Type.CONST` associated-const access: when the base is a
+                // module-scoped type and that module declares the (per-file
+                // flattened) associated constant, resolve the whole access to the
+                // module-qualified const symbol. This handles the cross-file case,
+                // where the access lives in a different file than the declaration.
+                if let Expr::Ident(type_name, _) = base.as_ref()
+                    && !scope.contains(type_name)
+                    && let Some(type_module) = self.resolve_type_module(file, type_name)
+                {
+                    let flat = flatten_associated_const(type_name, name);
+                    if self
+                        .module_defs
+                        .get(&type_module)
+                        .is_some_and(|names| names.contains(&flat))
+                    {
+                        *expr = Expr::Ident(self.mangle_value(&type_module, &flat), span.clone());
+                        return;
+                    }
+                }
+                self.rewrite_expr(base, file, scope);
+            }
             Expr::Index { base, index, .. } => {
                 self.rewrite_expr(base, file, scope);
                 self.rewrite_expr(index, file, scope);
@@ -545,14 +625,13 @@ impl Resolver {
                 }
                 // `module.function`: a module-qualified free call collapses to the
                 // module's mangled function symbol.
-                let module_prefix = namespace.replace('.', "_");
+                let prefix = module_prefix_from_dotted(namespace);
                 if self
                     .module_defs
-                    .get(&module_prefix)
+                    .get(&prefix)
                     .is_some_and(|names| names.contains(name))
                 {
-                    let mangled = format!("{module_prefix}{MODULE_SEP}{name}");
-                    *callee = Callee::Name(mangled);
+                    *callee = Callee::Name(format!("{prefix}{MODULE_SEP}{name}"));
                 }
             }
             Callee::ReceiverCall { receiver, .. } => {
@@ -704,6 +783,28 @@ mod tests {
         );
     }
 
+    #[test]
+    fn module_prefix_is_injective_across_dotted_and_underscored_paths() {
+        // `a.b` and `a_b` are distinct module paths and must not share a prefix.
+        let dotted = module_prefix(&["a".to_string(), "b".to_string()]);
+        let underscored = module_prefix(&["a_b".to_string()]);
+        assert_ne!(dotted, underscored);
+        assert_eq!(dotted, "a_b");
+        assert_eq!(underscored, "a__b");
+        assert_eq!(module_prefix_from_dotted("a.b"), "a_b");
+    }
+
+    #[test]
+    fn two_modules_with_colliding_join_keep_distinct_symbols() {
+        let ab = parse_source("ab.rss", "module a.b\n\nfn count() -> Int {\n    return 1\n}\n");
+        let a_b = parse_source("a_b.rss", "module a_b\n\nfn count() -> Int {\n    return 2\n}\n");
+        let mut program = merge_programs([ab, a_b]);
+        isolate_module_namespaces(&mut program);
+        let names = function_names(&program);
+        assert!(names.contains(&"a_b__count".to_string()), "{names:?}");
+        assert!(names.contains(&"a__b__count".to_string()), "{names:?}");
+    }
+
     #[test]
     fn entry_point_main_is_never_qualified() {
         let mut program = parse_source(
@@ -715,6 +816,13 @@ mod tests {
     }
 }
 
+/// The flattened symbol for an associated constant `Type.MEMBER`, matching the
+/// `desugar::associated_consts` flattening (`.` -> `_`, upper-cased) so isolation
+/// resolves to the same constant the per-file desugar produced.
+fn flatten_associated_const(type_name: &str, member: &str) -> String {
+    format!("{type_name}_{member}").to_uppercase()
+}
+
 fn item_file(item: &Item) -> Option<&str> {
     Some(match item {
         Item::Function(function) => function.span.file.as_str(),

crates/rsscript/tests/checker_lowering/misc.rs

@@ -84,6 +84,68 @@ fn module_isolation_lets_two_modules_share_a_symbol_name() {
     );
 }
 
+#[test]
+fn module_isolation_resolves_cross_file_associated_constant() {
+    // `Device.DEFAULT` is declared in one module and read from another (via
+    // `use device.Device`). The associated-const access must resolve to the
+    // module-qualified, upper-cased constant rather than a dangling field access.
+    let sources = vec![
+        (
+            "device.rss".to_string(),
+            "module device\n\nstruct Device {\n    name: String\n}\n\nconst Device.DEFAULT: String = \"cpu\"\n".to_string(),
+        ),
+        (
+            "main.rss".to_string(),
+            concat!(
+                "module app\n\n",
+                "use device.Device\n\n",
+                "fn main() -> Unit {\n",
+                "    Log.write(message: read Device.DEFAULT)\n",
+                "    return Unit\n",
+                "}\n",
+            )
+            .to_string(),
+        ),
+    ];
+    let package =
+        lower_sources_to_rust_package_with_options(&sources, "assoc-demo", "/rt", &[], &[])
+            .expect("cross-file associated constant should lower");
+    // The constant lowers to a module-qualified SCREAMING_SNAKE symbol, used at
+    // both declaration and the cross-file reference.
+    assert!(
+        package.lib_rs.contains("DEVICE__DEVICE_DEFAULT"),
+        "associated const should lower to a module-qualified symbol:\n{}",
+        package.lib_rs
+    );
+}
+
+#[test]
+fn module_isolation_distinguishes_dotted_and_underscored_module_paths() {
+    // `module a.b` and `module a_b` are distinct and must not collide (RS0005).
+    let sources = vec![
+        (
+            "ab.rss".to_string(),
+            "module a.b\n\nfn count() -> Int {\n    return 1\n}\n".to_string(),
+        ),
+        (
+            "a_b.rss".to_string(),
+            "module a_b\n\nfn count() -> Int {\n    return 2\n}\n".to_string(),
+        ),
+        (
+            "main.rss".to_string(),
+            "module app\n\nfn main() -> Unit {\n    return Unit\n}\n".to_string(),
+        ),
+    ];
+    let package =
+        lower_sources_to_rust_package_with_options(&sources, "collide-demo", "/rt", &[], &[])
+            .expect("distinct module paths should lower without collision");
+    assert!(
+        package.lib_rs.contains("fn a_b__count(") && package.lib_rs.contains("fn a__b__count("),
+        "distinct module paths must yield distinct symbols:\n{}",
+        package.lib_rs
+    );
+}
+
 #[test]
 fn lower_name_pin_renames_definition_and_call_sites() {
     let source = r#"

crates/rsscript/tests/golden/lowering/simple.rs

@@ -1,6 +1,6 @@
 // Generated by RSScript. Edit the .rss source instead.
 // Runtime hooks are intentionally explicit while Rust lowering is stabilizing.
-#![allow(dead_code, non_snake_case)]
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
 // RSScript features: <none>
 
 // rss:span kind=type file=simple.rss line=1 column=1 length=6