wesl 0.6.48 → 0.7.0

package/src/parse/ParseStatement.ts

@@ -0,0 +1,215 @@
+import type {
+  AttributeElem,
+  BlockStatement,
+  ContinuingElem,
+  ElifAttribute,
+  ElseAttribute,
+  IfAttribute,
+  StatementElem,
+} from "../AbstractElems.ts";
+import { findMap } from "../Util.ts";
+import { beginElem, finishElem } from "./ContentsHelpers.ts";
+import { parseAttributeList } from "./ParseAttribute.ts";
+import { parseIfStatement, parseSwitchStatement } from "./ParseControlFlow.ts";
+import { parseConstAssert } from "./ParseGlobalVar.ts";
+import { parseLetDecl, parseLocalVarDecl } from "./ParseLocalVar.ts";
+import {
+  parseContinuingStatement,
+  parseForStatement,
+  parseLoopStatement,
+  parseWhileStatement,
+} from "./ParseLoop.ts";
+import { parseSimpleStatement } from "./ParseSimpleStatement.ts";
+import {
+  attachAttributes,
+  expect,
+  hasConditionalAttribute,
+  isConditionalAttribute,
+  throwParseError,
+} from "./ParseUtil.ts";
+import { parseConstDecl } from "./ParseValueDeclaration.ts";
+import type { ParsingContext } from "./ParsingContext.ts";
+
+type CondAttr = IfAttribute | ElifAttribute | ElseAttribute;
+
+interface CompoundOptions {
+  loopBody?: boolean;
+  noScope?: boolean; // for function bodies (scope shared with params)
+}
+
+// Experimental: declarations in conditional blocks visible in outer scope.
+// e.g. @if(X) { let y = 1; } makes y visible outside the block.
+// see https://github.com/wgsl-tooling-wg/wesl-spec/issues/158
+const conditionalBlockFeature = true;
+
+/** Function bodies share scope with parameters (per WGSL spec). */
+export function parseFunctionBody(ctx: ParsingContext): StatementElem | null {
+  return parseCompoundStatement(ctx, undefined, { noScope: true });
+}
+
+/**
+ * Grammar: '{' statement* '}' (attributes parsed by caller)
+ * For loop bodies: '{' statement* continuing_statement? '}'
+ */
+export function parseCompoundStatement(
+  ctx: ParsingContext,
+  attributes?: AttributeElem[],
+  options?: CompoundOptions,
+): StatementElem | null {
+  const brace = ctx.stream.matchText("{");
+  if (!brace) return null;
+
+  const startPos = getStartWithAttributes(attributes, brace.span[0]);
+
+  beginElem(ctx, "statement", attributes);
+
+  const skipScope =
+    options?.noScope ||
+    (conditionalBlockFeature && hasConditionalAttr(attributes));
+  if (!skipScope) ctx.pushScope();
+  parseBlockStatements(ctx, options?.loopBody);
+  if (!skipScope) ctx.popScope();
+
+  return finishBlockStatement(startPos, ctx, attributes);
+}
+
+/** Grammar: attribute* compound_statement (for control flow bodies) */
+export function expectCompound(
+  ctx: ParsingContext,
+  errorMsg: string,
+  loopBody?: boolean,
+): StatementElem {
+  const attrs = parseAttributeList(ctx);
+  const attrsOrUndef = attrs.length > 0 ? attrs : undefined;
+  const options = loopBody ? { loopBody } : undefined;
+  const block = parseCompoundStatement(ctx, attrsOrUndef, options);
+  if (!block) throwParseError(ctx.stream, errorMsg);
+  return block;
+}
+
+/** Get start position from first attribute, or keyword position. */
+export function getStartWithAttributes(
+  attributes: AttributeElem[] | undefined,
+  keywordPos: number,
+): number {
+  return attributes?.[0]?.start ?? keywordPos;
+}
+
+/** Match keyword and begin statement element. Returns start position or null. */
+export function beginStatement(
+  ctx: ParsingContext,
+  keyword: string,
+  attributes?: AttributeElem[],
+  kind: "statement" | "continuing" = "statement",
+): number | null {
+  const keywordPos = ctx.stream.checkpoint();
+  if (!ctx.stream.matchText(keyword)) return null;
+  const startPos = getStartWithAttributes(attributes, keywordPos);
+  beginElem(ctx, kind, attributes);
+  return startPos;
+}
+
+/** Finish block statement element: close contents, attach attributes. */
+export function finishBlockStatement(
+  start: number,
+  ctx: ParsingContext,
+  attributes?: AttributeElem[],
+): StatementElem;
+export function finishBlockStatement(
+  start: number,
+  ctx: ParsingContext,
+  attributes: AttributeElem[] | undefined,
+  kind: "continuing",
+): ContinuingElem;
+export function finishBlockStatement(
+  start: number,
+  ctx: ParsingContext,
+  attributes?: AttributeElem[],
+  kind: "statement" | "continuing" = "statement",
+): BlockStatement {
+  const elem = finishElem(kind, start, ctx, {});
+  attachAttributes(elem, attributes);
+  return elem;
+}
+
+function hasConditionalAttr(attributes?: AttributeElem[]): boolean {
+  return !!attributes && hasConditionalAttribute(attributes);
+}
+
+/** Grammar: statement* '}' (after '{' consumed). Loop bodies may end with continuing. */
+function parseBlockStatements(ctx: ParsingContext, loopBody?: boolean): void {
+  const { stream } = ctx;
+  while (true) {
+    if (stream.matchText("}")) break;
+    const stmt = parseStatement(ctx);
+    if (!stmt) throwParseError(stream, "Expected statement or '}'");
+    ctx.addElem(stmt);
+    if (loopBody && stmt.kind === "continuing") {
+      expect(stream, "}", "continuing block");
+      break;
+    }
+  }
+}
+
+/**
+ * Grammar: statement :
+ *   ';' | return_statement ';' | if_statement | switch_statement | loop_statement
+ *   | for_statement | while_statement | func_call_statement ';'
+ *   | variable_or_value_statement ';' | break_statement ';' | continue_statement ';'
+ *   | 'discard' ';' | variable_updating_statement ';' | compound_statement
+ *   | const_assert_statement ';'
+ */
+function parseStatement(ctx: ParsingContext): BlockStatement | null {
+  const { stream } = ctx;
+  const startPos = stream.checkpoint();
+  const attributes = parseAttributeList(ctx);
+
+  const token = stream.peek();
+  if (!token || token.text === "}") {
+    stream.reset(startPos);
+    return null;
+  }
+
+  const hasConditional =
+    attributes.length > 0 && hasConditionalAttribute(attributes);
+  if (hasConditional) ctx.pushScope("partial");
+
+  const attrsOrUndef = attributes.length > 0 ? attributes : undefined;
+  const parsers = [
+    parseLocalVarDecl,
+    parseLetDecl,
+    parseConstDecl,
+    parseConstAssert,
+    parseCompoundStatement,
+    parseIfStatement,
+    parseSwitchStatement,
+    parseForStatement,
+    parseWhileStatement,
+    parseLoopStatement,
+    parseContinuingStatement,
+    parseSimpleStatement,
+  ];
+  const stmt = findMap(parsers, p => p(ctx, attrsOrUndef));
+  if (!stmt) return null;
+
+  finalizeConditional(ctx, hasConditional, attributes);
+  return stmt as BlockStatement;
+}
+
+function finalizeConditional(
+  ctx: ParsingContext,
+  hasConditional: boolean,
+  attributes: AttributeElem[],
+): void {
+  if (hasConditional) {
+    const partialScope = ctx.popScope();
+    partialScope.condAttribute = getConditionalAttribute(attributes);
+  }
+}
+
+function getConditionalAttribute(
+  attributes: AttributeElem[],
+): CondAttr | undefined {
+  const found = attributes.find(a => isConditionalAttribute(a.attribute));
+  return found?.attribute as CondAttr | undefined;
+}

package/src/parse/ParseStruct.ts

@@ -0,0 +1,89 @@
+import type {
+  AttributeElem,
+  StructElem,
+  StructMemberElem,
+} from "../AbstractElems.ts";
+import { beginElem, finishElem } from "./ContentsHelpers.ts";
+import { parseAttributeList } from "./ParseAttribute.ts";
+import { getStartWithAttributes } from "./ParseStatement.ts";
+import { parseSimpleTypeRef } from "./ParseType.ts";
+import {
+  attachAttributes,
+  createDeclIdentElem,
+  expect,
+  expectWord,
+  linkDeclIdentElem,
+  makeNameElem,
+  parseCommaList,
+  throwParseError,
+} from "./ParseUtil.ts";
+import type { ParsingContext } from "./ParsingContext.ts";
+
+/**
+ * Grammar: struct_decl : 'struct' ident struct_body_decl
+ * Grammar: struct_body_decl : '{' struct_member ( ',' struct_member )* ','? '}'
+ */
+export function parseStructDecl(
+  ctx: ParsingContext,
+  attributes?: AttributeElem[],
+): StructElem | null {
+  const { stream } = ctx;
+  const structToken = stream.matchText("struct");
+  if (!structToken) return null;
+
+  const start = getStartWithAttributes(attributes, structToken.span[0]);
+  const nameToken = expectWord(stream, "Expected identifier after 'struct'");
+
+  const identElem = createDeclIdentElem(ctx, nameToken, true);
+  ctx.saveIdent(identElem.ident);
+
+  beginElem(ctx, "struct", attributes);
+  ctx.addElem(identElem);
+  expect(stream, "{", "struct name");
+
+  ctx.pushScope();
+  const members = parseStructMembers(ctx);
+  identElem.ident.dependentScope = ctx.currentScope();
+  ctx.popScope();
+
+  expect(stream, "}", "struct member");
+
+  const elem = finishElem("struct", start, ctx, { name: identElem, members });
+  attachAttributes(elem, attributes);
+  linkDeclIdentElem(identElem, elem);
+  return elem;
+}
+
+/** Grammar: struct_body_decl : '{' struct_member (',' struct_member)* ','? '}' */
+function parseStructMembers(ctx: ParsingContext): StructMemberElem[] {
+  const members = parseCommaList(ctx, parseStructMember);
+  for (const member of members) ctx.addElem(member);
+  return members;
+}
+
+/** Grammar: struct_member : attribute* member_ident ':' type_specifier */
+function parseStructMember(ctx: ParsingContext): StructMemberElem | null {
+  const { stream } = ctx;
+  const checkpoint = stream.checkpoint();
+  const attributes = parseAttributeList(ctx);
+
+  const nameToken = stream.matchKind("word");
+  if (!nameToken) {
+    stream.reset(checkpoint);
+    return null;
+  }
+
+  const start = getStartWithAttributes(attributes, nameToken.span[0]);
+  beginElem(ctx, "member", attributes.length ? attributes : undefined);
+  const name = makeNameElem(nameToken);
+  ctx.addElem(name);
+  expect(stream, ":", "struct member name");
+
+  const typeRef = parseSimpleTypeRef(ctx);
+  if (!typeRef) throwParseError(stream, "Expected type after ':'");
+  ctx.addElem(typeRef);
+
+  const elem = finishElem("member", start, ctx, { name, typeRef });
+  attachAttributes(elem, attributes.length ? attributes : undefined);
+  return elem;
+}

package/src/parse/ParseType.ts

@@ -0,0 +1,71 @@
+import type { TypeRefElem, TypeTemplateParameter } from "../AbstractElems.ts";
+import { beginElem, finishElem } from "./ContentsHelpers.ts";
+import { parseExpression } from "./ParseExpression.ts";
+import { parseModulePath } from "./ParseIdent.ts";
+import { makeRefIdentElem, throwParseError } from "./ParseUtil.ts";
+import type { ParsingContext } from "./ParsingContext.ts";
+import type { WeslStream } from "./WeslStream.ts";
+
+/**
+ * Grammar: type_specifier : template_elaborated_ident
+ * Grammar: template_elaborated_ident : ident template_list?
+ * WESL extension: qualified names with :: (e.g., pkg::Type)
+ */
+export function parseSimpleTypeRef(ctx: ParsingContext): TypeRefElem | null {
+  const path = parseModulePath(ctx.stream);
+  if (!path) return null;
+
+  const { parts, start, end: nameEnd } = path;
+  const refIdent = ctx.createRefIdent(parts.join("::"));
+
+  beginElem(ctx, "type");
+
+  const refIdentElem = makeRefIdentElem(ctx, refIdent, start, nameEnd);
+  ctx.saveIdent(refIdent);
+  ctx.addElem(refIdentElem);
+
+  const templateParams = ctx.stream.nextTemplateStartToken()
+    ? parseTemplateParams(ctx)
+    : undefined;
+
+  return finishElem("type", start, ctx, { name: refIdent, templateParams });
+}
+
+/** Parse comma-separated template parameters until closing '>'. */
+export function parseTemplateParams(
+  ctx: ParsingContext,
+): TypeTemplateParameter[] {
+  const { stream } = ctx;
+
+  // Handle empty template <>
+  if (consumeTemplateEnd(stream)) return [];
+
+  // Parse comma-separated params
+  const params: TypeTemplateParameter[] = [parseTemplateParam(ctx)];
+  while (stream.matchText(",")) {
+    params.push(parseTemplateParam(ctx));
+  }
+
+  // Must end with >
+  if (!consumeTemplateEnd(stream))
+    throwParseError(stream, "Expected '>' or ',' after template parameter");
+
+  return params;
+}
+
+/** Consume template end token (>) if present, returning success. */
+function consumeTemplateEnd(stream: WeslStream): boolean {
+  if (!stream.peek()?.text.startsWith(">")) return false;
+  if (!stream.nextTemplateEndToken())
+    throwParseError(stream, "Expected '>' to close template parameters");
+  return true;
+}
+
+/** Grammar: template_arg_expression : expression */
+function parseTemplateParam(ctx: ParsingContext): TypeTemplateParameter {
+  // parseExpression handles template_elaborated_ident via parsePrimaryExpr
+  // inTemplate prevents '>' from being parsed as comparison operator
+  const expr = parseExpression(ctx, { inTemplate: true });
+  if (expr) return expr;
+  throwParseError(ctx.stream, "Expected expression in template parameters");
+}

package/src/parse/ParseUtil.ts

@@ -0,0 +1,174 @@
+import type {
+  Attribute,
+  AttributeElem,
+  DeclarationElem,
+  DeclIdentElem,
+  ExpressionElem,
+  NameElem,
+  RefIdentElem,
+  TypedDeclElem,
+} from "../AbstractElems.ts";
+import { ParseError } from "../ParseError.ts";
+import type { RefIdent } from "../Scope.ts";
+import type { Stream, Token } from "../Stream.ts";
+import { parseExpression } from "./ParseExpression.ts";
+import type { ParsingContext } from "./ParsingContext.ts";
+import type { WeslStream, WeslToken } from "./WeslStream.ts";
+
+// --- Stream/token expectations ---
+
+/** Match text and throw ParseError if not found. */
+export function expect(
+  stream: WeslStream,
+  text: string,
+  context?: string,
+): ReturnType<WeslStream["matchText"]> & {} {
+  const token = stream.matchText(text);
+  if (!token) {
+    const pos = stream.checkpoint();
+    const msg = context
+      ? `Expected '${text}' after ${context}`
+      : `Expected '${text}'`;
+    throw new ParseError(msg, [pos, pos]);
+  }
+  return token;
+}
+
+/** Match word token and throw ParseError if not found. */
+export function expectWord(
+  stream: WeslStream,
+  errorMsg: string,
+): WeslToken<"word"> {
+  const token = stream.peek();
+  if (!token || token.kind !== "word") {
+    throwParseError(stream, errorMsg);
+  }
+  stream.nextToken();
+  return token as WeslToken<"word">;
+}
+
+/** Parse expression and throw ParseError if not found. */
+export function expectExpression(
+  ctx: ParsingContext,
+  errorMsg = "Expected expression",
+): ExpressionElem {
+  const expr = parseExpression(ctx);
+  if (!expr) throwParseError(ctx.stream, errorMsg);
+  return expr;
+}
+
+/** Throw a ParseError at the current/next token position. */
+export function throwParseError(stream: Stream<Token>, message: string): never {
+  const weslStream = stream as WeslStream;
+  const token = weslStream.peek();
+  const span = token
+    ? token.span
+    : ([weslStream.checkpoint(), weslStream.checkpoint()] as const);
+  throw new ParseError(message, span);
+}
+
+// --- List parsing ---
+
+/** Parse comma-separated items. Caller handles delimiters. */
+export function parseCommaList<T>(
+  ctx: ParsingContext,
+  parseItem: (ctx: ParsingContext) => T | null,
+): T[] {
+  const items: T[] = [];
+  while (true) {
+    const item = parseItem(ctx);
+    if (item === null) break;
+    items.push(item);
+    if (!ctx.stream.matchText(",")) break;
+  }
+  return items;
+}
+
+/** Yield parsed elements until parser returns null. */
+export function* parseMany<T>(
+  ctx: ParsingContext,
+  parse: (ctx: ParsingContext) => T | null,
+): Generator<T> {
+  for (let elem = parse(ctx); elem; elem = parse(ctx)) yield elem;
+}
+
+// --- Element creation ---
+
+/** Create a NameElem from a word token. */
+export function makeNameElem(token: WeslToken<"word">): NameElem {
+  const [start, end] = token.span;
+  return { kind: "name", name: token.text, start, end };
+}
+
+/** Create a DeclIdentElem from a name token. */
+export function createDeclIdentElem(
+  ctx: ParsingContext,
+  nameToken: WeslToken<"word">,
+  isGlobal: boolean,
+): DeclIdentElem {
+  const declIdent = ctx.createDeclIdent(nameToken.text, isGlobal);
+  const [start, end] = nameToken.span;
+  return {
+    kind: "decl",
+    ident: declIdent,
+    srcModule: ctx.srcModule,
+    start,
+    end,
+  };
+}
+
+/** Create a RefIdentElem and link it to its RefIdent. */
+export function makeRefIdentElem(
+  ctx: ParsingContext,
+  refIdent: RefIdent,
+  start: number,
+  end: number,
+): RefIdentElem {
+  const elem: RefIdentElem = {
+    kind: "ref",
+    ident: refIdent,
+    srcModule: ctx.srcModule,
+    start,
+    end,
+  };
+  refIdent.refIdentElem = elem;
+  return elem;
+}
+
+// --- Attribute utilities ---
+
+export function isConditionalAttribute(attr: Attribute): boolean {
+  const { kind } = attr;
+  return kind === "@if" || kind === "@elif" || kind === "@else";
+}
+
+/** @return true if any attribute is a conditional (@if, @elif, @else) */
+export function hasConditionalAttribute(attributes: AttributeElem[]): boolean {
+  return attributes.some(attr => isConditionalAttribute(attr.attribute));
+}
+
+/** Attach non-empty attributes array to element. */
+export function attachAttributes<T extends { attributes?: AttributeElem[] }>(
+  elem: T,
+  attributes?: AttributeElem[],
+): void {
+  if (attributes?.length) elem.attributes = attributes;
+}
+
+// --- Declaration linking ---
+
+/** Link a DeclIdentElem's ident to its parent declaration. */
+export function linkDeclIdentElem(
+  declIdentElem: DeclIdentElem,
+  declElem: DeclarationElem,
+): void {
+  declIdentElem.ident.declElem = declElem;
+}
+
+/** Link a TypedDeclElem's ident to its parent declaration. */
+export function linkDeclIdent(
+  typedDecl: TypedDeclElem,
+  declElem: DeclarationElem,
+): void {
+  linkDeclIdentElem(typedDecl.decl, declElem);
+}

package/src/parse/ParseValueDeclaration.ts

@@ -0,0 +1,130 @@
+import type {
+  AttributeElem,
+  ConstElem,
+  ElemKindMap,
+  OverrideElem,
+  TypedDeclElem,
+  TypeRefElem,
+} from "../AbstractElems.ts";
+import type { Scope } from "../Scope.ts";
+import { beginElem, finishContents } from "./ContentsHelpers.ts";
+import { getStartWithAttributes } from "./ParseStatement.ts";
+import { parseSimpleTypeRef } from "./ParseType.ts";
+import {
+  attachAttributes,
+  createDeclIdentElem,
+  expect,
+  expectExpression,
+  linkDeclIdent,
+  throwParseError,
+} from "./ParseUtil.ts";
+import type { ParsingContext } from "./ParsingContext.ts";
+
+type ValueDeclKind = "const" | "override";
+
+/** Grammar: 'const' optionally_typed_ident '=' expression (global or local) */
+export function parseConstDecl(
+  ctx: ParsingContext,
+  attributes?: AttributeElem[],
+): ConstElem | null {
+  return parseValueDecl(ctx, "const", true, isModuleScope(ctx), attributes);
+}
+
+/** Grammar: 'override' optionally_typed_ident ( '=' expression )? */
+export function parseOverrideDecl(
+  ctx: ParsingContext,
+  attributes?: AttributeElem[],
+): OverrideElem | null {
+  return parseValueDecl(ctx, "override", false, true, attributes);
+}
+
+/** Grammar: optionally_typed_ident : ident ( ':' type_specifier )? */
+export function parseTypedDecl(
+  ctx: ParsingContext,
+  isGlobal = true,
+): TypedDeclElem | null {
+  const nameToken = ctx.stream.matchKind("word");
+  if (!nameToken) return null;
+  const start = nameToken.span[0];
+
+  beginElem(ctx, "typeDecl");
+  const decl = createDeclIdentElem(ctx, nameToken, isGlobal);
+  ctx.addElem(decl);
+  ctx.saveIdent(decl.ident);
+
+  const { typeRef, typeScope } = parseOptionalType(ctx);
+
+  const end = ctx.stream.checkpoint();
+  const contents = finishContents(ctx, start, end);
+  return { kind: "typeDecl", decl, typeRef, typeScope, start, end, contents };
+}
+
+/** Shared parser for const/override declarations. */
+function parseValueDecl<K extends ValueDeclKind>(
+  ctx: ParsingContext,
+  keyword: K,
+  requiresInit: boolean,
+  isGlobal: boolean,
+  attributes?: AttributeElem[],
+): ElemKindMap[K] | null {
+  const { stream } = ctx;
+  const token = stream.matchText(keyword);
+  if (!token) return null;
+
+  const startPos = getStartWithAttributes(attributes, token.span[0]);
+  ctx.pushScope("partial");
+  beginElem(ctx, keyword, attributes);
+
+  const typedDecl = parseTypedDecl(ctx, isGlobal);
+  if (!typedDecl)
+    throwParseError(stream, `Expected identifier after '${keyword}'`);
+  ctx.addElem(typedDecl);
+
+  if (requiresInit) {
+    expect(stream, "=", `${keyword} identifier`);
+    expectExpression(ctx);
+  } else if (stream.matchText("=")) {
+    expectExpression(ctx);
+  }
+
+  expect(stream, ";", `${keyword} declaration`);
+
+  const endPos = stream.checkpoint();
+  const contents = finishContents(ctx, startPos, endPos);
+  typedDecl.decl.ident.dependentScope = ctx.currentScope();
+  ctx.popScope();
+
+  const elem: ConstElem | OverrideElem = {
+    kind: keyword,
+    name: typedDecl,
+    start: startPos,
+    end: endPos,
+    contents,
+  };
+  attachAttributes(elem, attributes);
+  linkDeclIdent(typedDecl, elem);
+  return elem as ElemKindMap[K];
+}
+
+/** @return true if ctx is at module level (not inside fn/block) */
+function isModuleScope(ctx: ParsingContext): boolean {
+  let scope = ctx.currentScope();
+  while (scope.kind === "partial" && scope.parent) scope = scope.parent;
+  return scope.parent === null;
+}
+
+/** Parse optional ': type' annotation, managing scope for type references. */
+function parseOptionalType(ctx: ParsingContext): {
+  typeRef?: TypeRefElem;
+  typeScope?: Scope;
+} {
+  if (!ctx.stream.matchText(":")) return {};
+
+  ctx.pushScope();
+  const typeRef = parseSimpleTypeRef(ctx);
+  if (!typeRef) throwParseError(ctx.stream, "Expected type after ':'");
+  ctx.addElem(typeRef);
+  const typeScope = ctx.currentScope();
+  ctx.popScope();
+  return { typeRef, typeScope };
+}