wesl 0.6.48 → 0.7.0

package/src/parse/ParseIdent.ts

@@ -0,0 +1,77 @@
+import type { RefIdentElem } from "../AbstractElems.ts";
+import { makeRefIdentElem, throwParseError } from "./ParseUtil.ts";
+import type { ParsingContext } from "./ParsingContext.ts";
+import type { WeslStream, WeslToken } from "./WeslStream.ts";
+
+export interface ParsedModulePath {
+  parts: string[];
+  start: number;
+  end: number;
+}
+
+/** WESL keywords that cannot be used as path segment identifiers. */
+export const weslKeywords = new Set([
+  "as",
+  "import",
+  "package",
+  "super",
+  "self",
+]);
+const pathPrefixKeywords = new Set(["package", "super"]);
+
+/** Parse qualified module path like a::b::c, returning parts and span. */
+export function parseModulePath(stream: WeslStream): ParsedModulePath | null {
+  const first = stream.peek();
+  if (!first || !isPathSegment(first, true)) return null;
+
+  const start = first.span[0];
+  stream.nextToken();
+  const parts = [first.text];
+
+  while (stream.matchText("::")) {
+    const next = stream.peek();
+    if (!next || !isPathSegment(next, false))
+      throwParseError(stream, "Expected identifier after '::'");
+    stream.nextToken();
+    parts.push(next.text);
+  }
+
+  return { parts, start, end: stream.checkpoint() };
+}
+
+/**
+ * Parse identifier, possibly qualified with :: (e.g., package::bar, super::baz).
+ * @param conditionRef - if true, ident gets conditionRef flag and isn't added to scope
+ */
+export function parseIdent(
+  ctx: ParsingContext,
+  conditionRef?: true,
+): RefIdentElem | null {
+  const path = parseModulePath(ctx.stream);
+  if (!path) return null;
+
+  const { parts, start, end } = path;
+  const ident = ctx.createRefIdent(parts.join("::"));
+  if (conditionRef) ident.conditionRef = true;
+
+  const refIdentElem = makeRefIdentElem(ctx, ident, start, end);
+
+  // Don't add conditionRef idents to scope - they're only in the expression tree
+  if (!conditionRef) {
+    ctx.saveIdent(ident);
+    ctx.addElem(refIdentElem);
+  }
+
+  return refIdentElem;
+}
+
+/** Check if token is valid as a path segment (word or allowed keyword). */
+function isPathSegment(token: WeslToken, isFirst: boolean): boolean {
+  if (token.kind === "word") return true;
+  if (token.kind !== "keyword") return false;
+  if (weslKeywords.has(token.text)) {
+    // package/super allowed only as first segment
+    return isFirst && pathPrefixKeywords.has(token.text);
+  }
+  return true; // other keywords (reserved words) allowed
+}

package/src/parse/ParseImport.ts

@@ -0,0 +1,160 @@
+/** Token-based parsers for WESL import statements working directly with WeslStream. */
+
+import type {
+  ImportCollection,
+  ImportElem,
+  ImportItem,
+  ImportSegment,
+  ImportStatement,
+} from "../AbstractElems.ts";
+import { parseWeslConditional } from "./ParseAttribute.ts";
+import { weslKeywords } from "./ParseIdent.ts";
+import { parseMany, throwParseError } from "./ParseUtil.ts";
+import type { ParsingContext } from "./ParsingContext.ts";
+import type { WeslStream } from "./WeslStream.ts";
+
+/** WESL Grammar: translation_unit : import_statement* global_directive* global_decl* */
+export function parseWeslImports(ctx: ParsingContext): ImportElem[] {
+  return [...parseMany(ctx, parseImportStatement)];
+}
+
+/** Grammar: import_statement : conditional_attribute? 'import' import_relative? (import_collection | import_path_or_item) ';' */
+function parseImportStatement(ctx: ParsingContext): ImportElem | null {
+  const { stream } = ctx;
+  const condAttr = parseWeslConditional(ctx);
+
+  const parseResult = parseImportStatementBase(stream);
+  if (!parseResult) {
+    if (condAttr) stream.reset(condAttr.start);
+    return null;
+  }
+
+  const { statement: imports, importPos } = parseResult;
+  const start = condAttr?.start ?? importPos;
+  const end = stream.checkpoint();
+  const attributes = condAttr ? [condAttr] : undefined;
+  return { kind: "import", imports, start, end, attributes };
+}
+
+/** Parse: import <relative>? <collection_or_path> ';' */
+function parseImportStatementBase(
+  stream: WeslStream,
+): { statement: ImportStatement; importPos: number } | null {
+  const importToken = stream.matchText("import");
+  if (!importToken) return null;
+
+  const relative = parseImportRelative(stream) ?? [];
+  const parsed = parseImportCollection(stream) || parseImportPathOrItem(stream);
+  if (!parsed) throwParseError(stream, "invalid import, expected { or name");
+  if (!stream.matchText(";"))
+    throwParseError(stream, "invalid import, expected ';'");
+
+  const isStatement = parsed.kind === "import-statement";
+  const statement = isStatement
+    ? prependSegments(relative, parsed)
+    : makeStatement(relative, parsed);
+  return { statement, importPos: importToken.span[0] };
+}
+
+/** WESL Grammar: import_relative : 'package' '::' | 'super' '::' ('super' '::')* */
+function parseImportRelative(stream: WeslStream): ImportSegment[] | null {
+  if (stream.matchSequence("package", "::")) return [makeSegment("package")];
+
+  const segments: ImportSegment[] = [];
+  while (stream.matchSequence("super", "::")) {
+    segments.push(makeSegment("super"));
+  }
+  return segments.length > 0 ? segments : null;
+}
+
+/** WESL Grammar: import_collection : '{' import_path_or_item (',' import_path_or_item)* ','? '}' */
+function parseImportCollection(stream: WeslStream): ImportCollection | null {
+  if (!stream.matchText("{")) return null;
+
+  const msg = "invalid import collection, expected name";
+  const first = parseImportPathOrItem(stream);
+  if (!first) throwParseError(stream, msg);
+  const statements: ImportStatement[] = [first];
+
+  while (stream.matchText(",")) {
+    if (stream.peek()?.text === "}") break;
+    const item = parseImportPathOrItem(stream);
+    if (!item) throwParseError(stream, msg + " after ','");
+    statements.push(item);
+  }
+
+  if (!stream.matchText("}"))
+    throwParseError(stream, "invalid import collection, expected }");
+  return makeCollection(statements);
+}
+
+/**
+ * WESL Grammar: import_path_or_item :
+ *   ident '::' (import_collection | import_path_or_item) | ident ('as' ident)?
+ */
+function parseImportPathOrItem(stream: WeslStream): ImportStatement | null {
+  const name = parsePackageWord(stream);
+  if (!name) return null;
+
+  if (stream.matchText("::")) {
+    const segment = makeSegment(name);
+
+    const collection = parseImportCollection(stream);
+    if (collection) return makeStatement([segment], collection);
+
+    const pathOrItem = parseImportPathOrItem(stream);
+    if (pathOrItem) return prependSegments([segment], pathOrItem);
+
+    throwParseError(stream, "invalid import, expected '{' or name");
+  }
+
+  if (stream.matchText("as")) {
+    const alias = stream.matchKind("word");
+    if (!alias) throwParseError(stream, "invalid alias, expected name");
+    return makeStatement([], makeImportItem(name, alias.text));
+  }
+
+  return makeStatement([], makeImportItem(name));
+}
+
+/** Prepend path segments to an existing statement */
+function prependSegments(
+  segments: ImportSegment[],
+  statement: ImportStatement,
+): ImportStatement {
+  return { ...statement, segments: segments.concat(statement.segments) };
+}
+
+// -- AST node constructors --
+
+function makeStatement(
+  segments: ImportSegment[],
+  finalSegment: ImportCollection | ImportItem,
+): ImportStatement {
+  return { kind: "import-statement", segments, finalSegment };
+}
+
+function makeSegment(name: string): ImportSegment {
+  return { kind: "import-segment", name };
+}
+
+function makeCollection(subtrees: ImportStatement[]): ImportCollection {
+  return { kind: "import-collection", subtrees };
+}
+
+/** @return word/keyword token text usable in import path, or null if it's a WESL keyword */
+function parsePackageWord(stream: WeslStream): string | null {
+  const token = stream.peek();
+  if (!token) return null;
+
+  const { text, kind } = token;
+  if (kind !== "word" && kind !== "keyword") return null;
+  if (weslKeywords.has(text)) return null;
+
+  stream.nextToken();
+  return text;
+}
+
+function makeImportItem(name: string, as?: string): ImportItem {
+  return { kind: "import-item", name, as };
+}

package/src/parse/ParseLocalVar.ts

@@ -0,0 +1,69 @@
+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 {
+  attachAttributes,
+  expect,
+  expectExpression,
+  linkDeclIdent,
+  throwParseError,
+} from "./ParseUtil.ts";
+import { parseTypedDecl } from "./ParseValueDeclaration.ts";
+import type { ParsingContext } from "./ParsingContext.ts";
+
+/**
+ * Grammar: variable_or_value_statement : variable_decl | variable_decl '=' expression
+ * Grammar: variable_decl : 'var' template_list? optionally_typed_ident
+ */
+export function parseLocalVarDecl(
+  ctx: ParsingContext,
+  attributes?: AttributeElem[],
+): VarElem | null {
+  return parseVarOrLet(ctx, "var", true, false, attributes) as VarElem | null;
+}
+
+/** Grammar: 'let' optionally_typed_ident '=' expression */
+export function parseLetDecl(
+  ctx: ParsingContext,
+  attributes?: AttributeElem[],
+): LetElem | null {
+  return parseVarOrLet(ctx, "let", false, true, attributes) as LetElem | null;
+}
+
+/** Shared logic for var/let declarations. */
+function parseVarOrLet(
+  ctx: ParsingContext,
+  keyword: "var" | "let",
+  hasTemplate: boolean,
+  requiresInit: boolean,
+  attributes?: AttributeElem[],
+): VarElem | LetElem | null {
+  const { stream } = ctx;
+  const token = stream.matchText(keyword);
+  if (!token) return null;
+
+  const startPos = getStartWithAttributes(attributes, token.span[0]);
+  beginElem(ctx, keyword, attributes);
+  if (hasTemplate) skipTemplateList(ctx);
+
+  const typedDecl = parseTypedDecl(ctx, false);
+  if (!typedDecl)
+    throwParseError(stream, `Expected identifier after '${keyword}'`);
+  ctx.addElem(typedDecl);
+
+  if (requiresInit) {
+    const msg = `${keyword} identifier (${keyword} requires initialization)`;
+    expect(stream, "=", msg);
+    expectExpression(ctx);
+  } else if (stream.matchText("=")) {
+    expectExpression(ctx);
+  }
+
+  expect(stream, ";", `${keyword} declaration`);
+
+  const elem = finishElem(keyword, startPos, ctx, { name: typedDecl });
+  attachAttributes(elem, attributes);
+  linkDeclIdent(typedDecl, elem);
+  return elem;
+}

package/src/parse/ParseLoop.ts

@@ -0,0 +1,112 @@
+import type {
+  AttributeElem,
+  ContinuingElem,
+  StatementElem,
+} from "../AbstractElems.ts";
+import { parseExpression } from "./ParseExpression.ts";
+import { parseLocalVarDecl } from "./ParseLocalVar.ts";
+import {
+  parseAssignmentRhs,
+  parseIncDecOperator,
+} from "./ParseSimpleStatement.ts";
+import {
+  beginStatement,
+  expectCompound,
+  finishBlockStatement,
+} from "./ParseStatement.ts";
+import { expect, expectExpression } from "./ParseUtil.ts";
+import type { ParsingContext } from "./ParsingContext.ts";
+
+/**
+ * Grammar: for_statement : attribute* 'for' '(' for_header ')' compound_statement
+ * Grammar: for_header : for_init? ';' expression? ';' for_update?
+ */
+export function parseForStatement(
+  ctx: ParsingContext,
+  attributes?: AttributeElem[],
+): StatementElem | null {
+  const { stream } = ctx;
+  const startPos = beginStatement(ctx, "for", attributes);
+  if (startPos === null) return null;
+
+  ctx.pushScope();
+  expect(stream, "(", "'for'");
+
+  parseForInit(ctx);
+  parseExpression(ctx); // returns null if empty condition
+  expect(stream, ";", "for loop condition");
+  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);
+}
+
+/** Grammar: while_statement : attribute* 'while' expression compound_statement */
+export function parseWhileStatement(
+  ctx: ParsingContext,
+  attributes?: AttributeElem[],
+): StatementElem | null {
+  const startPos = beginStatement(ctx, "while", attributes);
+  if (startPos === null) return null;
+
+  expectExpression(ctx, "Expected condition expression after 'while'");
+
+  const body = expectCompound(ctx, "Expected '{' after while condition");
+  ctx.addElem(body);
+
+  return finishBlockStatement(startPos, ctx, attributes);
+}
+
+/** Grammar: loop_statement : attribute* 'loop' attribute* '{' statement* continuing_statement? '}' */
+export function parseLoopStatement(
+  ctx: ParsingContext,
+  attributes?: AttributeElem[],
+): StatementElem | null {
+  const startPos = beginStatement(ctx, "loop", attributes);
+  if (startPos === null) return null;
+
+  const body = expectCompound(ctx, "Expected '{' after 'loop'", true);
+  ctx.addElem(body);
+
+  return finishBlockStatement(startPos, ctx, attributes);
+}
+
+/** Grammar: continuing_statement : 'continuing' continuing_compound_statement */
+export function parseContinuingStatement(
+  ctx: ParsingContext,
+  attributes?: AttributeElem[],
+): ContinuingElem | null {
+  const startPos = beginStatement(ctx, "continuing", attributes, "continuing");
+  if (startPos === null) return null;
+
+  const body = expectCompound(ctx, "Expected '{' after 'continuing'");
+  ctx.addElem(body);
+
+  return finishBlockStatement(startPos, ctx, attributes, "continuing");
+}
+
+/** Grammar: for_init? ';'
+ *           for_init : variable_or_value_statement | variable_updating_statement | func_call_statement
+ */
+function parseForInit(ctx: ParsingContext): void {
+  const { stream } = ctx;
+  const varDecl = parseLocalVarDecl(ctx);
+  if (varDecl) {
+    ctx.addElem(varDecl);
+    // parseLocalVarDecl already consumed the ';'
+  } else {
+    parseExpression(ctx); // returns null for empty case
+    expect(stream, ";", "for loop init");
+  }
+}
+
+/** Grammar: for_update : variable_updating_statement | func_call_statement
+ *           variable_updating_statement : assignment_statement | increment_statement | decrement_statement */
+function parseForUpdate(ctx: ParsingContext): void {
+  parseExpression(ctx);
+  parseIncDecOperator(ctx.stream) || parseAssignmentRhs(ctx);
+}

package/src/parse/ParseModule.ts

@@ -0,0 +1,116 @@
+import type {
+  Attribute,
+  AttributeElem,
+  ConditionalAttribute,
+  ConstAssertElem,
+  GlobalDeclarationElem,
+} from "../AbstractElems.ts";
+import { findMap } from "../Util.ts";
+import { parseAttributeList } from "./ParseAttribute.ts";
+import { parseDirective } from "./ParseDirective.ts";
+import { parseFnDecl } from "./ParseFn.ts";
+import {
+  parseAliasDecl,
+  parseConstAssert,
+  parseGlobalVarDecl,
+} from "./ParseGlobalVar.ts";
+import { parseWeslImports } from "./ParseImport.ts";
+import { parseStructDecl } from "./ParseStruct.ts";
+import {
+  hasConditionalAttribute,
+  parseMany,
+  throwParseError,
+} from "./ParseUtil.ts";
+import { parseConstDecl, parseOverrideDecl } from "./ParseValueDeclaration.ts";
+import type { ParsingContext } from "./ParsingContext.ts";
+
+const declParsers = [
+  parseConstDecl,
+  parseOverrideDecl,
+  parseGlobalVarDecl,
+  parseAliasDecl,
+  parseStructDecl,
+  parseFnDecl,
+  parseConstAssert,
+];
+
+/** Grammar: translation_unit : global_directive* ( global_decl | global_assert | ';' )* */
+export function parseModule(ctx: ParsingContext): void {
+  parseImports(ctx);
+  parseDirectives(ctx);
+  while (parseNextDeclaration(ctx)) {}
+}
+
+/** 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.state.stable.imports.push(importElem.imports);
+  }
+}
+
+/** 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);
+}
+
+/** Parse one declaration, return true if more may exist. */
+function parseNextDeclaration(ctx: ParsingContext): boolean {
+  const { stream } = ctx;
+  if (stream.matchText(";")) return true;
+
+  const attrs = parseAttributeList(ctx);
+  const hasConditional = hasConditionalAttribute(attrs);
+  if (hasConditional) ctx.pushScope("partial");
+
+  const parsed = parseDecl(ctx, attrs);
+  if (hasConditional && parsed) finalizeConditional(ctx, attrs);
+
+  if (parsed) return true;
+  if (attrs.length)
+    throwParseError(stream, "Expected declaration after attributes");
+  return false;
+}
+
+/** 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;
+}
+
+/** Pop conditional scope and attach the conditional attribute. */
+function finalizeConditional(
+  ctx: ParsingContext,
+  attrs: AttributeElem[],
+): void {
+  const partialScope = ctx.popScope();
+  partialScope.condAttribute = findMap(attrs, ({ attribute }) =>
+    isConditionalAttribute(attribute) ? attribute : undefined,
+  );
+}
+
+/** Record a parsed declaration, extending start to include attributes. */
+function recordDecl(
+  ctx: ParsingContext,
+  elem: GlobalDeclarationElem | ConstAssertElem,
+  attrs: AttributeElem[],
+): void {
+  if (attrs.length && elem.start > attrs[0].start) elem.start = attrs[0].start;
+  ctx.addElem(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

@@ -0,0 +1,162 @@
+import type { AttributeElem, StatementElem } from "../AbstractElems.ts";
+import { beginElem, finishContents } from "./ContentsHelpers.ts";
+import { parseExpression } from "./ParseExpression.ts";
+import {
+  finishBlockStatement,
+  getStartWithAttributes,
+} from "./ParseStatement.ts";
+import { expect, expectExpression, throwParseError } from "./ParseUtil.ts";
+import type { ParsingContext } from "./ParsingContext.ts";
+import type { WeslStream } from "./WeslStream.ts";
+
+const assignmentOps = new Set([
+  "=",
+  "+=",
+  "-=",
+  "*=",
+  "/=",
+  "%=",
+  "&=",
+  "|=",
+  "^=",
+  "<<=",
+  ">>=",
+]);
+
+/**
+ * Grammar: return_statement : 'return' expression?
+ * Grammar: break_statement : 'break' | 'break' 'if' expression
+ * Grammar: continue_statement : 'continue'
+ * Grammar: variable_updating_statement : assignment_statement | increment_statement | decrement_statement
+ * Grammar: func_call_statement : call_phrase
+ */
+export function parseSimpleStatement(
+  ctx: ParsingContext,
+  attributes?: AttributeElem[],
+): StatementElem | 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") ||
+    parseEmptyStmt(stream, startPos) ||
+    parsePhonyAssignment(ctx, startPos, attributes) ||
+    parseExpressionStmt(ctx, startPos, attributes)
+  );
+}
+
+/** Grammar: return_statement : 'return' expression? ';' */
+function parseReturnStmt(
+  ctx: ParsingContext,
+  startPos: number,
+  attributes?: AttributeElem[],
+): StatementElem | null {
+  const { stream } = ctx;
+  if (!stream.matchText("return")) return null;
+  beginElem(ctx, "statement", attributes);
+  parseExpression(ctx);
+  expect(stream, ";", "return statement");
+  return finishBlockStatement(startPos, ctx, attributes);
+}
+
+/**
+ * Grammar: break_statement : 'break' ';'
+ * Grammar: break_if_statement : 'break' 'if' expression ';'
+ */
+function parseBreakStmt(
+  ctx: ParsingContext,
+  startPos: number,
+  attributes?: AttributeElem[],
+): StatementElem | null {
+  const { stream } = ctx;
+  if (!stream.matchText("break")) return null;
+  beginElem(ctx, "statement", attributes);
+  if (stream.matchText("if")) {
+    expectExpression(ctx, "Expected condition after 'break if'");
+  }
+  expect(stream, ";", "break statement");
+  return finishBlockStatement(startPos, ctx, attributes);
+}
+
+/** Grammar: continue_statement : 'continue' ';' also handles 'discard' */
+function parseKeywordStmt(
+  ctx: ParsingContext,
+  startPos: number,
+  attributes: AttributeElem[] | undefined,
+  keyword: string,
+): StatementElem | null {
+  const { stream } = ctx;
+  if (!stream.matchText(keyword)) return null;
+  beginElem(ctx, "statement", attributes);
+  expect(stream, ";", `${keyword} statement`);
+  return finishBlockStatement(startPos, ctx, attributes);
+}
+
+/** Parse empty statement (just ';'). */
+function parseEmptyStmt(
+  stream: WeslStream,
+  start: number,
+): StatementElem | null {
+  if (!stream.matchText(";")) return null;
+  const end = stream.checkpoint();
+  return { kind: "statement", start, end, contents: [] };
+}
+
+/** Grammar: assignment_statement : '_' '=' expression ';' (phony assignment) */
+function parsePhonyAssignment(
+  ctx: ParsingContext,
+  startPos: number,
+  attributes?: AttributeElem[],
+): StatementElem | 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");
+  expect(stream, ";", "assignment");
+  return finishBlockStatement(startPos, ctx, attributes);
+}
+
+/**
+ * Parses expression statements: assignments, increments/decrements, or function calls.
+ * Grammar: ( assignment_statement | increment_statement | decrement_statement | call_phrase ) ';'
+ */
+function parseExpressionStmt(
+  ctx: ParsingContext,
+  startPos: number,
+  attributes?: AttributeElem[],
+): StatementElem | null {
+  const { stream } = ctx;
+  beginElem(ctx, "statement", attributes);
+  const expr = parseExpression(ctx);
+  if (!expr) {
+    finishContents(ctx, startPos, startPos);
+    stream.reset(startPos);
+    return null;
+  }
+
+  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));
+}
+
+/** 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;
+}
+
+/** Grammar: increment_statement : lhs_expression '++' ; decrement_statement : lhs_expression '--' */
+export function parseIncDecOperator(stream: WeslStream): boolean {
+  return !!stream.nextIf(({ text }) => text === "++" || text === "--");
+}