Reject semicolonless simple statements

Author: Milky2018

docs/moon_wgsl-issue-tracker.md

@@ -13,6 +13,7 @@ Last updated: 2026-05-08
 
 | ID | Source | Problem | Status | Notes |
 | --- | --- | --- | --- | --- |
+| `WGSL-261` | Strict statement terminators | The statement collector treated a closing `}` as a valid terminator for simple statements, so invalid WGSL like `z = 1.0 }` could be accepted by moon_wgsl even though Naga rejects it with `expected ;`. | `DONE` | Statement collection now records whether a statement ended with a top-level semicolon, and strict AST validation marks semicolon-required statements invalid when the semicolon is missing. Template interpolation braces from naga_oil-style `#{...}` are tracked separately from WGSL block braces, so recursive block validation does not descend into source templates. Added parser regressions for assignment, return, and function-call statements without semicolons, and verified the real wgpu `issue_4485.wgsl` invalid source is now rejected before IR lowering. |
 | `WGSL-260` | Composer semantic phase architecture | Even after composer rewrites became symbol-binding-first, several phase boundaries still compressed semantic objects into strings: semantic reference facts were `HashSet[String]`, compose bindings carried `from_name/to_name/identity?`, live binding resolution stored `resolved_to_name`, and transform rewrite bindings accepted string reference names. | `DONE` | Added structured semantic reference path sets, changed compose bindings to carry `WgslSemanticReferencePath` plus a non-optional `WgslComposeSymbolTarget`, changed live binding resolution to pass target symbol objects instead of resolved-name strings, and changed transform rewrite plans to accept `WgslReferencePath` rather than string bindings. Added architecture guardrails banning `add_symbol_binding`, optional identity compose bindings, string-only semantic reference sets, and resolved-name phase state. Verification is tracked with this audit pass on 2026-05-08. |
 | `WGSL-259` | Composer symbol-binding architecture | `WgslReferenceRewritePlan` carried stable symbol identities but still exposed binding rewrites by downgrading them into `WgslRenamePlan`; the final AST rewrite therefore remained name-first at the execution boundary, and unqualified duplicate import bindings could remain ambiguous until transform declined a rewrite. | `DONE` | Removed the binding-plan-to-rename-plan adapters, removed optional identity from plain rename rules, and made reference/declaration binding rewrites consume `WgslReferenceRewriteBinding` directly when collecting AST identifier nodes. Composer binding sets now reject same-scope/same-reference bindings that point at different identities, including unqualified imports. Added guardrails preventing `reference_rename_plan` / `global_declaration_rename_plan` from returning and documenting that composer rewrites must remain symbol-binding-first. Verification is tracked with this audit pass on 2026-05-08. |
 | `WGSL-258` | 100% WGSL/naga-oil quality gate | External real-project WGSL scanning still allowed skipped files to remain implicit, so coverage regressions could hide behind a stable aggregate skipped count. | `IN_PROGRESS` | Replaced the skipped-file path with `testdata/external_wgsl_corpus_expected_failures.tsv`; the external corpus gate now reports `skipped=0` and every non-materialized file is an expected-failure contract keyed by `(repo, rel_path, reason)`. Added real Bevy sprite/UI render source roots plus concrete Bevy tonemapping, deferred, environment-map, SSR, UI, and meshlet profiles; added texture-atomic/cooperative-matrix/64-bit-image-atomic/f64/mesh-shader/ray-hit-vertex-position/per-vertex/binding-array IR/oracle validation plus duplicate import-path candidate selection for Bevy dummy/real modules. Added manifest-owned source materialization for real projects that concatenate, generate, or specialize WGSL before shader module creation, covering wgpu timestamp normalization, wgpu mesh shaders, wgpu ray-query vertex-return shaders, wgpu binding-array and per-vertex shaders, webgpu-samples Cornell shader suffixes/template replacement, webgpu-samples skinned-mesh generated vertex input, and primitive-index/barycentric/multiview validation capabilities. This raises Bevy to 158 source-valid / 149 composed-valid, wgpu to 77 source-valid, Naga to 122 source-valid, webgpu-samples to 68 source-valid, and total external corpus coverage to 475 source-valid files. Remaining work is to burn down the 25 expected failures by fixing the listed compose/IR/profile gaps or proving the external source is intentionally invalid under standalone validation. |

parser/wgsl_ast_expr_type.mbt

@@ -1084,20 +1084,63 @@ priv struct WgslTokenDepth {
   mut angle : Int
   mut bracket : Int
   mut brace : Int
+  mut source_template_pending_hash : Bool
+  mut source_template_brace : Int
 }
 
 ///|
 fn WgslTokenDepth::WgslTokenDepth() -> WgslTokenDepth {
-  WgslTokenDepth::{ paren: 0, angle: 0, bracket: 0, brace: 0 }
+  WgslTokenDepth::{
+    paren: 0,
+    angle: 0,
+    bracket: 0,
+    brace: 0,
+    source_template_pending_hash: false,
+    source_template_brace: 0,
+  }
 }
 
 ///|
 fn WgslTokenDepth::at_top(self : WgslTokenDepth) -> Bool {
-  self.paren == 0 && self.angle == 0 && self.bracket == 0 && self.brace == 0
+  self.paren == 0 &&
+  self.angle == 0 &&
+  self.bracket == 0 &&
+  self.brace == 0 &&
+  self.source_template_brace == 0
+}
+
+///|
+fn WgslTokenDepth::observe_source_template(
+  self : WgslTokenDepth,
+  token : WgslToken,
+) -> Bool {
+  if self.source_template_brace > 0 {
+    match token.punctuation_code() {
+      Some(123) => self.source_template_brace = self.source_template_brace + 1
+      Some(125) => self.source_template_brace = self.source_template_brace - 1
+      _ => ()
+    }
+    self.source_template_pending_hash = false
+    return true
+  }
+  if self.source_template_pending_hash && token.is_punctuation(123) {
+    self.source_template_brace = 1
+    self.source_template_pending_hash = false
+    return true
+  }
+  if token.is_punctuation(35) {
+    self.source_template_pending_hash = true
+  } else if !token.is_whitespace() {
+    self.source_template_pending_hash = false
+  }
+  false
 }
 
 ///|
 fn WgslTokenDepth::observe(self : WgslTokenDepth, token : WgslToken) -> Unit {
+  if self.observe_source_template(token) {
+    return
+  }
   match token.operator_text() {
     Some(">>") => {
       if self.angle >= 2 {
@@ -1127,6 +1170,9 @@ fn WgslTokenDepth::observe_statement_token(
   self : WgslTokenDepth,
   token : WgslToken,
 ) -> Unit {
+  if self.observe_source_template(token) {
+    return
+  }
   match token.punctuation_code() {
     Some(40) => self.paren = self.paren + 1
     Some(41) => self.paren = self.paren - 1

parser/wgsl_ast_statements.mbt

@@ -423,7 +423,11 @@ fn WgslDeclParser::collect_statement_blocks(
 ) -> Array[WgslBlock] {
   let blocks : Array[WgslBlock] = []
   let open_stack : Array[Int] = []
+  let source_template = WgslTokenDepth()
   for i in 0..<tokens.length() {
+    if source_template.observe_source_template(tokens[i]) {
+      continue
+    }
     if tokens[i].is_punctuation(123) {
       open_stack.push(i)
     } else if tokens[i].is_punctuation(125) {
@@ -453,12 +457,14 @@ fn collect_wgsl_statement_scope_tokens(
 ) -> Array[WgslToken] {
   let scope_tokens : Array[WgslToken] = []
   let mut block_depth = 0
+  let source_template = WgslTokenDepth()
   for token in tokens {
-    if token.is_punctuation(123) {
+    let source_template_token = source_template.observe_source_template(token)
+    if !source_template_token && token.is_punctuation(123) {
       block_depth = block_depth + 1
       continue
     }
-    if token.is_punctuation(125) && block_depth > 0 {
+    if !source_template_token && token.is_punctuation(125) && block_depth > 0 {
       block_depth = block_depth - 1
       continue
     }
@@ -1072,12 +1078,17 @@ fn wgsl_statement_has_invalid_expression(
   kind : WgslStatementKind,
   tokens : Array[WgslToken],
   expressions : Array[WgslStatementExpression],
+  missing_semicolon_at_statement_boundary : Bool,
 ) -> Bool {
   for token in tokens {
     if token.is_punctuation(35) {
       return false
     }
   }
+  if wgsl_statement_requires_semicolon(kind, tokens) &&
+    missing_semicolon_at_statement_boundary {
+    return true
+  }
   match kind {
     Return =>
       tokens.length() > 1 &&
@@ -1126,6 +1137,34 @@ fn wgsl_statement_has_invalid_expression(
   }
 }
 
+///|
+fn wgsl_statement_requires_semicolon(
+  kind : WgslStatementKind,
+  tokens : Array[WgslToken],
+) -> Bool {
+  match tokens {
+    [token, ..] if token.is_punctuation(35) => return false
+    [token, ..] if token.is_identifier("case") || token.is_identifier("default") =>
+      return false
+    [] => return false
+    _ => ()
+  }
+  match kind {
+    LocalDeclaration
+    | Return
+    | Break
+    | Continue
+    | Discard
+    | ConstAssert
+    | Assignment
+    | Increment
+    | Decrement
+    | FunctionCall
+    | Expression => true
+    _ => false
+  }
+}
+
 ///|
 fn wgsl_statement_payload_from_ast(
   kind : WgslStatementKind,
@@ -1283,6 +1322,7 @@ fn WgslDeclParser::collect_statement(self : WgslDeclParser) -> WgslStatement? {
   let mut first_identifier : String? = None
   let mut start_pos = -1
   let mut end_pos = -1
+  let mut missing_semicolon_at_statement_boundary = false
   let depth = WgslTokenDepth()
   fn record_span(start : Int, end_ : Int) -> Unit {
     if start_pos < 0 {
@@ -1295,7 +1335,12 @@ fn WgslDeclParser::collect_statement(self : WgslDeclParser) -> WgslStatement? {
   }
   while true {
     match self.view() {
-      [token, ..] if depth.at_top() && token.is_punctuation(125) => break
+      [token, ..] if depth.at_top() && token.is_punctuation(125) => {
+        if tokens.length() > 0 {
+          missing_semicolon_at_statement_boundary = true
+        }
+        break
+      }
       [token, .. rest] if depth.at_top() && token.is_punctuation(59) => {
         let pos = token.pos()
         record_span(pos, pos + 1)
@@ -1323,7 +1368,12 @@ fn WgslDeclParser::collect_statement(self : WgslDeclParser) -> WgslStatement? {
         }
         continue
       }
-      [] => break
+      [] => {
+        if tokens.length() > 0 {
+          missing_semicolon_at_statement_boundary = true
+        }
+        break
+      }
     }
   }
   if start_pos < 0 || end_pos < start_pos {
@@ -1378,7 +1428,7 @@ fn WgslDeclParser::collect_statement(self : WgslDeclParser) -> WgslStatement? {
       expressions,
     )
     let invalid_expression = wgsl_statement_has_invalid_expression(
-      kind, scope_tokens, expressions,
+      kind, scope_tokens, expressions, missing_semicolon_at_statement_boundary,
     )
     let blocks = self.collect_statement_blocks(tokens)
     Some(

parser/wgsl_ast_wbtest.mbt

@@ -129,6 +129,37 @@ test "strict WGSL translation unit rejects invalid numeric literals" {
   }
 }
 
+///|
+test "strict WGSL translation unit rejects semicolonless simple statements" {
+  let sources = [
+    (
+      #|fn assignment_missing_semicolon() {
+      #|  var z = 0.0;
+      #|  z = 1.0
+      #|}
+    ),
+    (
+      #|fn return_missing_semicolon() -> u32 {
+      #|  return 1u
+      #|}
+    ),
+    (
+      #|fn call_missing_semicolon() {
+      #|  workgroupBarrier()
+      #|}
+    ),
+  ]
+  for source in sources {
+    let mut failed = false
+    ignore(parse_wgsl_translation_unit_strict(source)) catch {
+      _ => failed = true
+    }
+    guard failed is true else {
+      abort("expected missing statement semicolon to fail: \{source}")
+    }
+  }
+}
+
 ///|
 test "WGSL numeric literal tokens expose raw descriptor" {
   let source =