rsscript: module glob import, qualified variant patterns; verify value access

Finishes the three docs/requests module items:

1. module-value-access (R2) — was a false alarm: qualified `module.CONST` /
   `module.Variant` value access already works through the *merged* semantic
   checker (isolation runs before body checks). The reopened RS0026 came from
   single-file `rss check`, which can't resolve ANY cross-module reference
   (even `use ops.Ops` fails the same way). Added a checker-level regression
   test (analyze_sources_with_interfaces) and corrected the doc.

2. module-glob-import — `use module.*` now parses (no RS0015) and imports every
   bare-referenceable module symbol (functions, consts, types, sums, aliases)
   into the file scope; variants resolve globally via their sum type. Expanded
   in a second pass once the module symbol tables are complete.

3. module-qualified-variant-pattern — the pattern parser accepts a dotted head
   (`ops.ADD`, `a.b.Variant`); isolation rewrites it to the bare variant
   (and `module.Type { .. }` payload patterns to the mangled type).

Each verified through the semantic checker on a merged multi-file program (three
new tests in checker_frontend). Still deferred: cross-module same-named-variant
disambiguation (needs variant namespacing). lib 111 / frontend 197 / lowering
225 / vm_eval 17 green.

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

Author: olwang

crates/rsscript/src/formatter.rs

@@ -124,7 +124,9 @@ impl Formatter {
                 Item::Use(u) => {
                     self.out.push_str("use ");
                     self.out.push_str(&u.path.join("."));
-                    if let Some(alias) = &u.alias {
+                    if u.glob {
+                        self.out.push_str(".*");
+                    } else if let Some(alias) = &u.alias {
                         self.out.push_str(" as ");
                         self.out.push_str(alias);
                     }

crates/rsscript/src/syntax/ast.rs

@@ -145,13 +145,20 @@ pub struct UseDecl {
     /// Optional `as <alias>` local name. When present, the import is referenced
     /// in this file by the alias instead of the path's last segment.
     pub alias: Option<String>,
+    /// `use module.*` — import every public symbol of the module named by `path`.
+    /// A glob has no single local name and cannot carry an alias.
+    pub glob: bool,
     pub span: Span,
 }
 
 impl UseDecl {
     /// The local name this import is referenced by in its file: the alias when
-    /// present, otherwise the path's last segment.
+    /// present, otherwise the path's last segment. A glob import has no single
+    /// local name.
     pub fn local_name(&self) -> Option<&str> {
+        if self.glob {
+            return None;
+        }
         self.alias
             .as_deref()
             .or_else(|| self.path.last().map(String::as_str))

crates/rsscript/src/syntax/module_isolation.rs

@@ -100,6 +100,8 @@ impl Resolver {
         let mut module_consts: HashMap<String, HashSet<String>> = HashMap::new();
         let mut module_variants: HashMap<String, HashSet<String>> = HashMap::new();
         let mut file_imports: HashMap<String, HashMap<String, (String, String)>> = HashMap::new();
+        // (file, module prefix) for each `use module.*`, expanded after the loop.
+        let mut glob_imports: Vec<(String, String)> = Vec::new();
 
         for item in &program.items {
             let Some(file) = item_file(item) else {
@@ -168,6 +170,12 @@ impl Resolver {
                         .or_default()
                         .insert(decl.name.clone());
                 }
+                Item::Use(decl) if decl.glob => {
+                    // `use module.*` imports every symbol of `module`. The module's
+                    // symbol table isn't fully populated until the loop finishes,
+                    // so record the glob and expand it in a second pass below.
+                    glob_imports.push((decl.span.file.clone(), module_prefix(&decl.path)));
+                }
                 Item::Use(decl) => {
                     if decl.path.len() >= 2 {
                         let real_name = decl.path[decl.path.len() - 1].clone();
@@ -186,6 +194,23 @@ impl Resolver {
             }
         }
 
+        // Expand `use module.*` globs now that every module's symbol table is
+        // complete: import each of the module's bare-referenceable names (free
+        // functions, constants, types, sums, and aliases — everything in
+        // `module_defs`) under its own name. Sum variants resolve globally through
+        // their sum type and need no import.
+        for (file, prefix) in glob_imports {
+            let Some(names) = module_defs.get(&prefix) else {
+                continue;
+            };
+            let entry = file_imports.entry(file).or_default();
+            for name in names {
+                entry
+                    .entry(name.clone())
+                    .or_insert_with(|| (prefix.clone(), name.clone()));
+            }
+        }
+
         Self {
             file_module: file_module.clone(),
             module_defs,
@@ -507,6 +532,18 @@ impl Resolver {
             MatchPattern::Variant { name, binding, .. } => {
                 if let Some(mangled) = self.resolve_bare(file, name) {
                     *name = mangled;
+                } else if let Some((namespace, variant)) = name.rsplit_once('.') {
+                    // `module.Variant` qualified pattern resolves to the bare
+                    // variant (variant names resolve through their sum type),
+                    // mirroring qualified value access in expression position.
+                    let prefix = module_prefix_from_dotted(namespace);
+                    if self
+                        .module_variants
+                        .get(&prefix)
+                        .is_some_and(|variants| variants.contains(variant))
+                    {
+                        *name = variant.to_string();
+                    }
                 }
                 if let Some(binding) = binding {
                     self.rewrite_pattern(binding, file);
@@ -515,6 +552,22 @@ impl Resolver {
             MatchPattern::Struct { name, fields, .. } => {
                 if let Some(mangled) = self.resolve_bare(file, name) {
                     *name = mangled;
+                } else if let Some((namespace, type_name)) = name.rsplit_once('.') {
+                    // `module.Type { .. }` qualified struct/variant-payload pattern.
+                    let prefix = module_prefix_from_dotted(namespace);
+                    if self
+                        .module_types
+                        .get(&prefix)
+                        .is_some_and(|types| types.contains(type_name))
+                    {
+                        *name = format!("{prefix}{MODULE_SEP}{type_name}");
+                    } else if self
+                        .module_variants
+                        .get(&prefix)
+                        .is_some_and(|variants| variants.contains(type_name))
+                    {
+                        *name = type_name.to_string();
+                    }
                 }
                 for field in fields {
                     self.rewrite_field_pattern(field, file);

crates/rsscript/src/syntax/parser.rs

@@ -853,15 +853,27 @@ impl Parser<'_> {
         }
         self.index += 1;
         let path = self.parse_dotted_path()?;
+        // `use module.*` glob: `parse_dotted_path` consumes the trailing `.` and
+        // stops at `*` (not an identifier), leaving the cursor on it.
+        let glob = self.at_symbol("*");
+        if glob {
+            self.index += 1;
+        }
         // Optional `as <alias>` renames the import locally so a file can pull two
-        // same-leaf symbols from different modules without collision.
-        let alias = if self.at_ident("as") {
+        // same-leaf symbols from different modules without collision. A glob has
+        // no single local name, so it takes no alias.
+        let alias = if !glob && self.at_ident("as") {
             self.index += 1;
             self.take_ident_name()
         } else {
             None
         };
-        Some(UseDecl { path, alias, span })
+        Some(UseDecl {
+            path,
+            alias,
+            glob,
+            span,
+        })
     }
 
     /// Parse a dot-separated path like `package.contract.PackageContract`.
@@ -2311,6 +2323,23 @@ fn split_match_pattern_guard(tokens: &[Token], start: usize, end: usize) -> Opti
     None
 }
 
+/// Parse a pattern head name: a bare identifier (`ADD`) or a module-qualified
+/// dotted name (`ops.ADD`, `a.b.Variant`). Returns the joined name and the token
+/// index just past it.
+fn parse_dotted_pattern_name(tokens: &[Token], start: usize, end: usize) -> Option<(String, usize)> {
+    let mut name = ident_name(tokens.get(start)?)?.to_string();
+    let mut index = start + 1;
+    while index + 1 < end
+        && tokens[index].symbol(".")
+        && let Some(segment) = ident_name(&tokens[index + 1])
+    {
+        name.push('.');
+        name.push_str(segment);
+        index += 2;
+    }
+    Some((name, index))
+}
+
 fn parse_match_pattern(tokens: &[Token], start: usize, end: usize) -> Option<MatchPattern> {
     // A tuple pattern `(p0, p1, ..)` desugars to the synthetic `__TupleN` struct
     // pattern `__TupleN { item0: p0, item1: p1, .. }`. Checked before `trim_outer`
@@ -2354,40 +2383,43 @@ fn parse_match_pattern(tokens: &[Token], start: usize, end: usize) -> Option<Mat
             _ => {}
         }
     }
-    let name = ident_name(&tokens[start])?.to_string();
+    // The pattern head may be a bare name (`ADD`, `Some`) or a module-qualified
+    // variant/type (`ops.ADD`, `ops.Pair`). `head_end` is the token index just
+    // past the (possibly dotted) name.
+    let (name, head_end) = parse_dotted_pattern_name(tokens, start, end)?;
     if name == "_" {
         return Some(MatchPattern::Wildcard(tokens[start].span.clone()));
     }
-    if tokens.get(start + 1).is_some_and(|token| token.symbol("{")) {
-        let close = find_matching(tokens, start + 1, "{", "}")?;
+    if tokens.get(head_end).is_some_and(|token| token.symbol("{")) {
+        let close = find_matching(tokens, head_end, "{", "}")?;
         if close + 1 != end {
             return None;
         }
-        let (fields, has_rest) = parse_match_field_patterns(tokens, start + 2, close)?;
+        let (fields, has_rest) = parse_match_field_patterns(tokens, head_end + 1, close)?;
         return Some(MatchPattern::Struct {
             name,
             fields,
             has_rest,
             span: tokens[start].span.clone(),
         });
     }
-    let binding = if tokens.get(start + 1).is_some_and(|token| token.symbol("(")) {
-        let close = find_matching(tokens, start + 1, "(", ")")?;
+    let binding = if tokens.get(head_end).is_some_and(|token| token.symbol("(")) {
+        let close = find_matching(tokens, head_end, "(", ")")?;
         if close + 1 != end {
             return None;
         }
-        if start + 2 == close {
+        if head_end + 1 == close {
             None
-        } else if start + 3 == close && tokens[start + 2].is_ident_text("_") {
+        } else if head_end + 2 == close && tokens[head_end + 1].is_ident_text("_") {
             Some(Box::new(MatchPattern::Wildcard(
-                tokens[start + 2].span.clone(),
+                tokens[head_end + 1].span.clone(),
             )))
-        } else if start + 3 == close {
-            parse_single_payload_pattern(tokens, start + 2)
+        } else if head_end + 2 == close {
+            parse_single_payload_pattern(tokens, head_end + 1)
         } else {
-            parse_match_pattern(tokens, start + 2, close).map(Box::new)
+            parse_match_pattern(tokens, head_end + 1, close).map(Box::new)
         }
-    } else if start + 1 == end {
+    } else if head_end == end {
         None
     } else {
         return None;

crates/rsscript/tests/checker_frontend/misc.rs

@@ -2,6 +2,103 @@
 #![allow(unused_imports, dead_code)]
 use super::*;
 
+#[test]
+fn qualified_module_value_access_checks_clean_through_the_checker() {
+    // Regression guard: qualified `module.CONST` / `module.Variant` in value
+    // position must resolve through the *semantic checker* on a merged multi-file
+    // program — not only through the lowering helper. (`module-value-access.md`.)
+    let diagnostics = analyze_sources_with_interfaces(
+        &[
+            (
+                "ops.rss",
+                "module ops\n\nsum Ops { ADD MUL OTHER }\n\nconst MAX_OPS: Int = 64\n",
+            ),
+            (
+                "user.rss",
+                concat!(
+                    "module user\n\n",
+                    "use ops.Ops\n\n",
+                    "fn c() -> fresh Ops { return ops.MUL }\n\n",
+                    "fn e() -> Int { return ops.MAX_OPS }\n",
+                ),
+            ),
+        ],
+        &[],
+    );
+    assert_eq!(
+        diagnostics,
+        Vec::new(),
+        "qualified module value access should check clean: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn qualified_variant_in_match_pattern_checks_clean() {
+    // `ops.ADD` / `ops.MUL` as match patterns resolve through the merged checker
+    // (parser accepts the dotted pattern; isolation rewrites it to the bare
+    // variant). (`module-qualified-variant-pattern.md`.)
+    let diagnostics = analyze_sources_with_interfaces(
+        &[
+            ("ops.rss", "module ops\n\nsum Ops { ADD MUL OTHER }\n"),
+            (
+                "app.rss",
+                concat!(
+                    "module app\n\n",
+                    "use ops.Ops\n\n",
+                    "fn classify(o: read Ops) -> Int {\n",
+                    "    match read o {\n",
+                    "        ops.ADD => { return 1 }\n",
+                    "        ops.MUL => { return 2 }\n",
+                    "        _ => { return 0 }\n",
+                    "    }\n",
+                    "}\n",
+                ),
+            ),
+        ],
+        &[],
+    );
+    assert_eq!(
+        diagnostics,
+        Vec::new(),
+        "qualified variant in match pattern should check clean: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn glob_import_brings_module_symbols_into_scope() {
+    // `use ops.*` imports the module's type, const, and functions; bare variants
+    // resolve globally. The snippet checks clean. (`module-glob-import.md`.)
+    let diagnostics = analyze_sources_with_interfaces(
+        &[
+            (
+                "ops.rss",
+                "module ops\n\nsum Ops { ADD MUL OTHER }\n\nconst MAX_OPS: Int = 64\n\nfn helper() -> Int { return 1 }\n",
+            ),
+            (
+                "app.rss",
+                concat!(
+                    "module app\n\n",
+                    "use ops.*\n\n",
+                    "fn pick() -> fresh Ops { return ADD }\n\n",
+                    "fn lim() -> Int { return MAX_OPS }\n\n",
+                    "fn classify(o: read Ops) -> Int {\n",
+                    "    match read o {\n",
+                    "        ADD => { return 1 }\n",
+                    "        _ => { return helper() }\n",
+                    "    }\n",
+                    "}\n",
+                ),
+            ),
+        ],
+        &[],
+    );
+    assert_eq!(
+        diagnostics,
+        Vec::new(),
+        "glob import should bring module symbols into scope: {diagnostics:?}"
+    );
+}
+
 #[test]
 fn pass_fixtures_have_no_diagnostics() {
     for path in common::fixture_paths("tests/fixtures/pass") {

docs/requests/module-glob-import.md

@@ -1,8 +1,19 @@
 # Feature request: glob import `use module.*`
 
-**Status:** requested · **Driver:** tinygrad-rsmc module de-prefixing
+**Status:** IMPLEMENTED · **Driver:** tinygrad-rsmc module de-prefixing
 **Repro built on:** `rss` @ `6c6c57a`
 
+> **Resolution.** `use module.*` is supported. The parser accepts the `.*` glob
+> form (no more RS0015), and `module_isolation` imports every bare-referenceable
+> symbol of the module — functions, constants, types, sums, and type aliases —
+> into the file's scope (sum variants resolve globally through their sum type, so
+> they need no import). Verified through the semantic checker on a merged
+> multi-file program: `glob_import_brings_module_symbols_into_scope`
+> (`tests/checker_frontend/misc.rs`) — `Ops`, `MAX_OPS`, a function, and bare
+> variants all resolve in value, type, and pattern position. Cross-module
+> same-named-variant collisions are still out of scope (needs variant
+> namespacing), as noted below.
+
 ## Summary
 
 Support `use module.*` to bring every public symbol of a module (its types, sum

docs/requests/module-qualified-variant-pattern.md

@@ -1,8 +1,18 @@
 # Feature request: qualified sum variant in `match` pattern position
 
-**Status:** requested · **Driver:** tinygrad-rsmc module de-prefixing
+**Status:** IMPLEMENTED · **Driver:** tinygrad-rsmc module de-prefixing
 **Repro built on:** `rss` @ `6c6c57a`
 
+> **Resolution.** A module-qualified variant is accepted as a match pattern. The
+> pattern parser now reads a dotted head (`ops.ADD`, `a.b.Variant`) — no more
+> RS0015 — and `module_isolation` rewrites it to the bare variant (resolved
+> through its sum type), identical to qualified value access in expression
+> position. Exhaustiveness/typeck treat `ops.ADD` as the bare `ADD` it resolves
+> to. Verified through the semantic checker on a merged program:
+> `qualified_variant_in_match_pattern_checks_clean`
+> (`tests/checker_frontend/misc.rs`). Qualified `module.Type { .. }` payload
+> patterns resolve too.
+
 ## Summary
 
 Allow a module-qualified sum variant (`module.Variant`) as a pattern in a `match`