wesl 0.7.26 → 0.7.28

package/src/parse/ParseLocalVar.ts

@@ -1,9 +1,12 @@
-import type { AttributeElem, LetElem, VarElem } from "../AbstractElems.ts";
-import { beginElem, finishElem } from "./ContentsHelpers.ts";
-import { skipTemplateList } from "./ParseGlobalVar.ts";
-import { getStartWithAttributes } from "./ParseStatement.ts";
+import type {
+  AttributeElem,
+  ExpressionElem,
+  LetElem,
+  VarElem,
+} from "../AbstractElems.ts";
+import { parseTemplateList } from "./ParseGlobalVar.ts";
+import { finishStatement, getStartWithAttributes } from "./ParseStatement.ts";
 import {
-  attachAttributes,
   expect,
   expectExpression,
   linkDeclIdent,
@@ -44,26 +47,27 @@ function parseVarOrLet(
   if (!token) return null;
 
   const startPos = getStartWithAttributes(attributes, token.span[0]);
-  beginElem(ctx, keyword, attributes);
-  if (hasTemplate) skipTemplateList(ctx);
+  const template = hasTemplate ? parseTemplateList(ctx) : undefined;
 
   const typedDecl = parseTypedDecl(ctx, false);
   if (!typedDecl)
     throwParseError(stream, `Expected identifier after '${keyword}'`);
-  ctx.addElem(typedDecl);
 
+  let init: ExpressionElem | undefined;
   if (requiresInit) {
     const msg = `${keyword} identifier (${keyword} requires initialization)`;
     expect(stream, "=", msg);
-    expectExpression(ctx);
+    init = expectExpression(ctx);
   } else if (stream.matchText("=")) {
-    expectExpression(ctx);
+    init = expectExpression(ctx);
   }
 
   expect(stream, ";", `${keyword} declaration`);
 
-  const elem = finishElem(keyword, startPos, ctx, { name: typedDecl });
-  attachAttributes(elem, attributes);
+  const params = { name: typedDecl, init };
+  const elem = finishStatement(keyword, startPos, ctx, params, attributes);
+  // template lives outside the shared fields: only VarElem (not LetElem) has it.
+  if (template && elem.kind === "var") elem.template = template;
   linkDeclIdent(typedDecl, elem);
   return elem;
 }

package/src/parse/ParseLoop.ts

@@ -1,20 +1,26 @@
 import type {
   AttributeElem,
   ContinuingElem,
-  StatementElem,
+  ExpressionElem,
+  ForElem,
+  ForInit,
+  ForUpdate,
+  LoopElem,
+  WhileElem,
 } from "../AbstractElems.ts";
-import { parseExpression } from "./ParseExpression.ts";
 import { parseLocalVarDecl } from "./ParseLocalVar.ts";
-import {
-  parseAssignmentRhs,
-  parseIncDecOperator,
-} from "./ParseSimpleStatement.ts";
+import { parseAssignmentRhs, parseIncDecOp } from "./ParseSimpleStatement.ts";
 import {
   beginStatement,
   expectCompound,
-  finishBlockStatement,
+  finishStatement,
 } from "./ParseStatement.ts";
-import { expect, expectExpression } from "./ParseUtil.ts";
+import {
+  expect,
+  expectExpression,
+  parseContentExpression,
+  throwParseError,
+} from "./ParseUtil.ts";
 import type { ParsingContext } from "./ParsingContext.ts";
 
 /**
@@ -24,7 +30,7 @@ import type { ParsingContext } from "./ParsingContext.ts";
 export function parseForStatement(
   ctx: ParsingContext,
   attributes?: AttributeElem[],
-): StatementElem | null {
+): ForElem | null {
   const { stream } = ctx;
   const startPos = beginStatement(ctx, "for", attributes);
   if (startPos === null) return null;
@@ -32,48 +38,49 @@ export function parseForStatement(
   ctx.pushScope();
   expect(stream, "(", "'for'");
 
-  parseForInit(ctx);
-  const cond = parseExpression(ctx); // returns null if empty condition
-  if (cond && ctx.options.preserveExpressions) ctx.addElem(cond);
+  const init = parseForInit(ctx);
+  const condition = parseContentExpression(ctx) ?? undefined;
   expect(stream, ";", "for loop condition");
-  parseForUpdate(ctx);
+  const update = parseForUpdate(ctx);
   expect(stream, ")", "for loop header");
 
   const body = expectCompound(ctx, "Expected '{' after for loop header");
-  ctx.addElem(body);
   ctx.popScope();
 
-  return finishBlockStatement(startPos, ctx, attributes);
+  const params = { init, condition, update, body };
+  return finishStatement("for", startPos, ctx, params, attributes);
 }
 
 /** Grammar: while_statement : attribute* 'while' expression compound_statement */
 export function parseWhileStatement(
   ctx: ParsingContext,
   attributes?: AttributeElem[],
-): StatementElem | null {
+): WhileElem | null {
   const startPos = beginStatement(ctx, "while", attributes);
   if (startPos === null) return null;
 
-  expectExpression(ctx, "Expected condition expression after 'while'");
-
+  const condition = expectExpression(ctx, "Expected condition after 'while'");
   const body = expectCompound(ctx, "Expected '{' after while condition");
-  ctx.addElem(body);
 
-  return finishBlockStatement(startPos, ctx, attributes);
+  const params = { condition, body };
+  return finishStatement("while", startPos, ctx, params, attributes);
 }
 
 /** Grammar: loop_statement : attribute* 'loop' attribute* '{' statement* continuing_statement? '}' */
 export function parseLoopStatement(
   ctx: ParsingContext,
   attributes?: AttributeElem[],
-): StatementElem | null {
+): LoopElem | null {
   const startPos = beginStatement(ctx, "loop", attributes);
   if (startPos === null) return null;
 
   const body = expectCompound(ctx, "Expected '{' after 'loop'", true);
-  ctx.addElem(body);
+  const continuing = body.body.find(
+    (s): s is ContinuingElem => s.kind === "continuing",
+  );
 
-  return finishBlockStatement(startPos, ctx, attributes);
+  const params = { body, continuing };
+  return finishStatement("loop", startPos, ctx, params, attributes);
 }
 
 /** Grammar: continuing_statement : 'continuing' continuing_compound_statement */
@@ -81,35 +88,65 @@ export function parseContinuingStatement(
   ctx: ParsingContext,
   attributes?: AttributeElem[],
 ): ContinuingElem | null {
-  const startPos = beginStatement(ctx, "continuing", attributes, "continuing");
+  const startPos = beginStatement(ctx, "continuing", attributes);
   if (startPos === null) return null;
 
   const body = expectCompound(ctx, "Expected '{' after 'continuing'");
-  ctx.addElem(body);
+  const breakIf = body.body.find(s => s.kind === "break")?.condition;
 
-  return finishBlockStatement(startPos, ctx, attributes, "continuing");
+  const params = { body, breakIf };
+  return finishStatement("continuing", startPos, ctx, params, attributes);
 }
 
 /** Grammar: for_init? ';'
  *           for_init : variable_or_value_statement | variable_updating_statement | func_call_statement
  */
-function parseForInit(ctx: ParsingContext): void {
+function parseForInit(ctx: ParsingContext): ForInit | undefined {
   const { stream } = ctx;
   const varDecl = parseLocalVarDecl(ctx);
   if (varDecl) {
-    ctx.addElem(varDecl);
-    // parseLocalVarDecl already consumed the ';'
-  } else {
-    const expr = parseExpression(ctx); // returns null for empty case
-    if (expr && ctx.options.preserveExpressions) ctx.addElem(expr);
-    expect(stream, ";", "for loop init");
+    return varDecl; // parseLocalVarDecl already consumed the ';'
   }
+  const expr = parseContentExpression(ctx); // null for empty case
+  const update = expr ? finishForUpdate(ctx, expr) : undefined;
+  expect(stream, ";", "for loop init");
+  return update;
 }
 
-/** Grammar: for_update : variable_updating_statement | func_call_statement
- *           variable_updating_statement : assignment_statement | increment_statement | decrement_statement */
-function parseForUpdate(ctx: ParsingContext): void {
-  const expr = parseExpression(ctx);
-  if (expr && ctx.options.preserveExpressions) ctx.addElem(expr);
-  parseIncDecOperator(ctx.stream) || parseAssignmentRhs(ctx);
+/** Grammar: for_update : variable_updating_statement | func_call_statement */
+function parseForUpdate(ctx: ParsingContext): ForUpdate | undefined {
+  const expr = parseContentExpression(ctx);
+  if (!expr) return undefined;
+  return finishForUpdate(ctx, expr);
+}
+
+/**
+ * Build a typed for-init/for-update node from an already-parsed lhs expression,
+ * consuming its trailing operator (++/-- or an assignment + rhs).
+ */
+function finishForUpdate(ctx: ParsingContext, expr: ExpressionElem): ForUpdate {
+  const { stream } = ctx;
+  const start = expr.start;
+  const incDec = parseIncDecOp(stream);
+  if (incDec) {
+    const end = stream.checkpoint();
+    if (incDec.op === "++")
+      return { kind: "increment", target: expr, start, end };
+    return { kind: "decrement", target: expr, start, end };
+  }
+  const assign = parseAssignmentRhs(ctx);
+  if (assign) {
+    const { op, rhs } = assign;
+    const end = stream.checkpoint();
+    return { kind: "assign", lhs: expr, op, rhs, start, end };
+  }
+  if (expr.kind === "call-expression") {
+    return { kind: "call", call: expr, start, end: stream.checkpoint() };
+  }
+  // A bare expression (no ++/--/assignment, not a call) is not a valid for
+  // init/update clause; reject it rather than silently dropping it.
+  throwParseError(
+    stream,
+    "Expected an assignment, increment, decrement, or call in for-clause",
+  );
 }

package/src/parse/ParseModule.ts

@@ -1,13 +1,16 @@
 import type {
-  Attribute,
+  AbstractElem,
   AttributeElem,
-  ConditionalAttribute,
   ConstAssertElem,
   GlobalDeclarationElem,
+  ModuleElem,
 } from "../AbstractElems.ts";
+import { declsOfKind } from "../LinkerUtil.ts";
+import { ParseError } from "../ParseError.ts";
 import { findMap } from "../Util.ts";
 import { parseAttributeList } from "./ParseAttribute.ts";
 import { parseDirective } from "./ParseDirective.ts";
+import { parseDoBlock } from "./ParseDoBlock.ts";
 import { parseFnDecl } from "./ParseFn.ts";
 import {
   parseAliasDecl,
@@ -17,6 +20,8 @@ import {
 import { parseWeslImports } from "./ParseImport.ts";
 import { parseStructDecl } from "./ParseStruct.ts";
 import {
+  attrsOrUndef,
+  conditionalAttribute,
   hasConditionalAttribute,
   parseMany,
   throwParseError,
@@ -31,6 +36,7 @@ const declParsers = [
   parseAliasDecl,
   parseStructDecl,
   parseFnDecl,
+  parseDoBlock,
   parseConstAssert,
 ];
 
@@ -39,13 +45,46 @@ export function parseModule(ctx: ParsingContext): void {
   parseImports(ctx);
   parseDirectives(ctx);
   while (parseNextDeclaration(ctx)) {}
+  // reject input the declaration loop couldn't consume (e.g. a directive after a
+  // declaration, or stray tokens); otherwise it would be silently dropped
+  if (ctx.stream.peek() !== null)
+    throwParseError(ctx.stream, "Expected a declaration or directive");
+}
+
+/**
+ * Reject a module that gives a `do` block a name that clashes with a fn/global
+ * or with another `do` block (`do` blocks share the module's declaration
+ * namespace, and runners key blocks by name so a duplicate would silently
+ * shadow the earlier one). This is a small module-local pass, deliberately not
+ * part of bindIdents.
+ */
+export function checkDoBlockNames(moduleElem: ModuleElem): void {
+  const doBlocks = declsOfKind(moduleElem, "do");
+  if (doBlocks.length === 0) return;
+
+  const declNames = new Set(moduleElem.decls.map(globalDeclName));
+  const seen = new Set<string>();
+  for (const block of doBlocks) {
+    const { name, start, end } = block.name;
+    if (declNames.has(name))
+      throw new ParseError(`'${name}' declared as both fn and do`, [
+        start,
+        end,
+      ]);
+    if (seen.has(name))
+      throw new ParseError(`'${name}' declared as do more than once`, [
+        start,
+        end,
+      ]);
+    seen.add(name);
+  }
 }
 
 /** Parse WESL import statements at the start of the module. */
 function parseImports(ctx: ParsingContext): void {
   const importElems = parseWeslImports(ctx);
   for (const importElem of importElems) {
-    ctx.addElem(importElem);
+    ctx.addModuleDecl(importElem);
     ctx.state.stable.imports.push(importElem.imports);
   }
 }
@@ -53,7 +92,7 @@ function parseImports(ctx: ParsingContext): void {
 /** Grammar: global_directive : diagnostic_directive | enable_directive | requires_directive */
 function parseDirectives(ctx: ParsingContext): void {
   const directives = parseMany(ctx, parseDirective);
-  for (const elem of directives) ctx.addElem(elem);
+  for (const elem of directives) ctx.addModuleDecl(elem);
 }
 
 /** Parse one declaration, return true if more may exist. */
@@ -74,15 +113,28 @@ function parseNextDeclaration(ctx: ParsingContext): boolean {
   return false;
 }
 
+/** @return the declared name of a module-level declaration, if it has one. */
+function globalDeclName(elem: AbstractElem): string | undefined {
+  switch (elem.kind) {
+    case "fn":
+    case "struct":
+    case "alias":
+      return elem.name.ident.originalName;
+    case "gvar":
+    case "const":
+    case "override":
+      return elem.name.decl.ident.originalName;
+    default:
+      return undefined;
+  }
+}
+
 /** Try each declaration parser until one succeeds. */
 function parseDecl(ctx: ParsingContext, attrs: AttributeElem[]): boolean {
-  const attrsOrUndef = attrs.length ? attrs : undefined;
-  const elem = findMap(declParsers, p => p(ctx, attrsOrUndef));
-  if (elem) {
-    recordDecl(ctx, elem, attrs);
-    return true;
-  }
-  return false;
+  const elem = findMap(declParsers, p => p(ctx, attrsOrUndef(attrs)));
+  if (!elem) return false;
+  recordDecl(ctx, elem, attrs);
+  return true;
 }
 
 /** Pop conditional scope and attach the conditional attribute. */
@@ -91,9 +143,7 @@ function finalizeConditional(
   attrs: AttributeElem[],
 ): void {
   const partialScope = ctx.popScope();
-  partialScope.condAttribute = findMap(attrs, ({ attribute }) =>
-    isConditionalAttribute(attribute) ? attribute : undefined,
-  );
+  partialScope.condAttribute = conditionalAttribute(attrs);
 }
 
 /** Record a parsed declaration, extending start to include attributes. */
@@ -103,14 +153,10 @@ function recordDecl(
   attrs: AttributeElem[],
 ): void {
   if (attrs.length && elem.start > attrs[0].start) elem.start = attrs[0].start;
-  ctx.addElem(elem);
+  ctx.addModuleDecl(elem);
   if (elem.kind === "assert") {
     const { stable } = ctx.state;
     stable.moduleAsserts ??= [];
     stable.moduleAsserts.push(elem);
   }
 }
-
-function isConditionalAttribute(a: Attribute): a is ConditionalAttribute {
-  return a.kind === "@if" || a.kind === "@elif" || a.kind === "@else";
-}

package/src/parse/ParseSimpleStatement.ts

@@ -1,11 +1,28 @@
-import type { AttributeElem, StatementElem } from "../AbstractElems.ts";
-import { beginElem, finishContents } from "./ContentsHelpers.ts";
+import type {
+  AssignElem,
+  AssignOp,
+  AttributeElem,
+  BreakElem,
+  CallElem,
+  ContinueElem,
+  DecrementElem,
+  DiscardElem,
+  EmptyElem,
+  ExpressionElem,
+  IncrementElem,
+  PhonyTarget,
+  ReturnElem,
+  Statement,
+} from "../AbstractElems.ts";
+import type { Span } from "../Span.ts";
 import { parseExpression } from "./ParseExpression.ts";
+import { finishStatement, getStartWithAttributes } from "./ParseStatement.ts";
 import {
-  finishBlockStatement,
-  getStartWithAttributes,
-} from "./ParseStatement.ts";
-import { expect, expectExpression, throwParseError } from "./ParseUtil.ts";
+  expect,
+  expectExpression,
+  parseContentExpression,
+  throwParseError,
+} from "./ParseUtil.ts";
 import type { ParsingContext } from "./ParsingContext.ts";
 import type { WeslStream } from "./WeslStream.ts";
 
@@ -33,34 +50,61 @@ const assignmentOps = new Set([
 export function parseSimpleStatement(
   ctx: ParsingContext,
   attributes?: AttributeElem[],
-): StatementElem | null {
+): Statement | null {
   const { stream } = ctx;
   const startPos = getStartWithAttributes(attributes, stream.checkpoint());
 
   return (
     parseReturnStmt(ctx, startPos, attributes) ||
     parseBreakStmt(ctx, startPos, attributes) ||
-    parseKeywordStmt(ctx, startPos, attributes, "continue") ||
-    parseKeywordStmt(ctx, startPos, attributes, "discard") ||
+    parseContinueStmt(ctx, startPos, attributes) ||
+    parseDiscardStmt(ctx, startPos, attributes) ||
     parseEmptyStmt(stream, startPos) ||
     parsePhonyAssignment(ctx, startPos, attributes) ||
     parseExpressionStmt(ctx, startPos, attributes)
   );
 }
 
+/** Match an assignment operator, capturing its value and span. */
+export function parseAssignmentOp(stream: WeslStream): AssignOp | null {
+  const token = stream.nextIf(({ text }) => assignmentOps.has(text));
+  if (!token) return null;
+  return { value: token.text as AssignOp["value"], span: token.span };
+}
+
+/** Match '++' or '--', returning its text and span (or null if absent). */
+export function parseIncDecOp(
+  stream: WeslStream,
+): { op: "++" | "--"; span: Span } | null {
+  const token = stream.nextIf(({ text }) => text === "++" || text === "--");
+  if (!token) return null;
+  return { op: token.text as "++" | "--", span: token.span };
+}
+
+/** Grammar: ( '=' | compound_assignment_operator ) expression. Returns op + rhs. */
+export function parseAssignmentRhs(
+  ctx: ParsingContext,
+): { op: AssignOp; rhs: ExpressionElem } | null {
+  const op = parseAssignmentOp(ctx.stream);
+  if (!op) return null;
+  const rhs = expectExpression(
+    ctx,
+    "Expected expression after assignment operator",
+  );
+  return { op, rhs };
+}
+
 /** Grammar: return_statement : 'return' expression? ';' */
 function parseReturnStmt(
   ctx: ParsingContext,
   startPos: number,
   attributes?: AttributeElem[],
-): StatementElem | null {
+): ReturnElem | null {
   const { stream } = ctx;
   if (!stream.matchText("return")) return null;
-  beginElem(ctx, "statement", attributes);
-  const expr = parseExpression(ctx);
-  if (expr && ctx.options.preserveExpressions) ctx.addElem(expr);
+  const value = parseContentExpression(ctx) ?? undefined;
   expect(stream, ";", "return statement");
-  return finishBlockStatement(startPos, ctx, attributes);
+  return finishStatement("return", startPos, ctx, { value }, attributes);
 }
 
 /**
@@ -71,39 +115,46 @@ function parseBreakStmt(
   ctx: ParsingContext,
   startPos: number,
   attributes?: AttributeElem[],
-): StatementElem | null {
+): BreakElem | null {
   const { stream } = ctx;
   if (!stream.matchText("break")) return null;
-  beginElem(ctx, "statement", attributes);
+  let condition: ExpressionElem | undefined;
   if (stream.matchText("if")) {
-    expectExpression(ctx, "Expected condition after 'break if'");
+    condition = expectExpression(ctx, "Expected condition after 'break if'");
   }
   expect(stream, ";", "break statement");
-  return finishBlockStatement(startPos, ctx, attributes);
+  return finishStatement("break", startPos, ctx, { condition }, attributes);
 }
 
-/** Grammar: continue_statement : 'continue' ';' also handles 'discard' */
-function parseKeywordStmt(
+/** Grammar: continue_statement : 'continue' ';' */
+function parseContinueStmt(
   ctx: ParsingContext,
   startPos: number,
-  attributes: AttributeElem[] | undefined,
-  keyword: string,
-): StatementElem | null {
+  attributes?: AttributeElem[],
+): ContinueElem | null {
   const { stream } = ctx;
-  if (!stream.matchText(keyword)) return null;
-  beginElem(ctx, "statement", attributes);
-  expect(stream, ";", `${keyword} statement`);
-  return finishBlockStatement(startPos, ctx, attributes);
+  if (!stream.matchText("continue")) return null;
+  expect(stream, ";", "continue statement");
+  return finishStatement("continue", startPos, ctx, {}, attributes);
 }
 
-/** Parse empty statement (just ';'). */
-function parseEmptyStmt(
-  stream: WeslStream,
-  start: number,
-): StatementElem | null {
+/** Grammar: 'discard' ';' */
+function parseDiscardStmt(
+  ctx: ParsingContext,
+  startPos: number,
+  attributes?: AttributeElem[],
+): DiscardElem | null {
+  const { stream } = ctx;
+  if (!stream.matchText("discard")) return null;
+  expect(stream, ";", "discard statement");
+  return finishStatement("discard", startPos, ctx, {}, attributes);
+}
+
+/** Parse empty statement (just ';'). Spans the ';' so it emits no extra text. */
+function parseEmptyStmt(stream: WeslStream, start: number): EmptyElem | null {
   if (!stream.matchText(";")) return null;
   const end = stream.checkpoint();
-  return { kind: "statement", start, end, contents: [] };
+  return { kind: "empty", start, end };
 }
 
 /** Grammar: assignment_statement : '_' '=' expression ';' (phony assignment) */
@@ -111,54 +162,49 @@ function parsePhonyAssignment(
   ctx: ParsingContext,
   startPos: number,
   attributes?: AttributeElem[],
-): StatementElem | null {
+): AssignElem | null {
   const { stream } = ctx;
-  if (!stream.matchText("_")) return null;
-  if (!parseAssignmentOperator(stream))
-    throwParseError(stream, "Expected assignment operator after '_'");
-  beginElem(ctx, "statement", attributes);
-  expectExpression(ctx, "Expected expression after assignment operator");
+  const underscore = stream.matchText("_");
+  if (!underscore) return null;
+  const lhs: PhonyTarget = { kind: "phony", span: underscore.span };
+  // WGSL phony assignment uses only `=`, never a compound operator.
+  const eq = stream.matchText("=");
+  if (!eq) throwParseError(stream, "Expected '=' after '_'");
+  const op: AssignOp = { value: "=", span: eq.span };
+  const rhs = expectExpression(ctx, "Expected expression after '_ ='");
   expect(stream, ";", "assignment");
-  return finishBlockStatement(startPos, ctx, attributes);
+  return finishStatement("assign", startPos, ctx, { lhs, op, rhs }, attributes);
 }
 
-/**
- * Parses expression statements: assignments, increments/decrements, or function calls.
- * Grammar: ( assignment_statement | increment_statement | decrement_statement | call_phrase ) ';'
- */
+/** Grammar: ( assignment_statement | increment_statement | decrement_statement | call_phrase ) ';' */
 function parseExpressionStmt(
   ctx: ParsingContext,
   startPos: number,
   attributes?: AttributeElem[],
-): StatementElem | null {
+): AssignElem | IncrementElem | DecrementElem | CallElem | null {
   const { stream } = ctx;
-  beginElem(ctx, "statement", attributes);
   const expr = parseExpression(ctx);
   if (!expr) {
-    finishContents(ctx, startPos, startPos);
     stream.reset(startPos);
     return null;
   }
-  if (ctx.options.preserveExpressions) ctx.addElem(expr);
-
-  if (!parseIncDecOperator(stream)) parseAssignmentRhs(ctx);
-  expect(stream, ";", "expression");
-  return finishBlockStatement(startPos, ctx, attributes);
-}
 
-/** Grammar: assignment_statement : lhs_expression ( '=' | compound_assignment_operator ) expression */
-export function parseAssignmentOperator(stream: WeslStream): boolean {
-  return !!stream.nextIf(({ text }) => assignmentOps.has(text));
-}
+  const incDec = parseIncDecOp(stream);
+  if (incDec) {
+    expect(stream, ";", "expression");
+    const kind = incDec.op === "++" ? "increment" : "decrement";
+    return finishStatement(kind, startPos, ctx, { target: expr }, attributes);
+  }
 
-/** Grammar: ( '=' | compound_assignment_operator ) expression (rhs of assignment_statement) */
-export function parseAssignmentRhs(ctx: ParsingContext): boolean {
-  if (!parseAssignmentOperator(ctx.stream)) return false;
-  expectExpression(ctx, "Expected expression after assignment operator");
-  return true;
-}
+  const assign = parseAssignmentRhs(ctx);
+  expect(stream, ";", "expression");
+  if (assign) {
+    const params = { lhs: expr, op: assign.op, rhs: assign.rhs };
+    return finishStatement("assign", startPos, ctx, params, attributes);
+  }
 
-/** Grammar: increment_statement : lhs_expression '++' ; decrement_statement : lhs_expression '--' */
-export function parseIncDecOperator(stream: WeslStream): boolean {
-  return !!stream.nextIf(({ text }) => text === "++" || text === "--");
+  if (expr.kind !== "call-expression") {
+    throwParseError(stream, "Expected call, assignment, or increment");
+  }
+  return finishStatement("call", startPos, ctx, { call: expr }, attributes);
 }