wesl 0.7.26 → 0.7.28

package/src/parse/ParseControlFlow.ts

@@ -1,14 +1,21 @@
-import type { AttributeElem, StatementElem } from "../AbstractElems.ts";
-import { beginElem, finishElem } from "./ContentsHelpers.ts";
+import type {
+  AttributeElem,
+  BlockElem,
+  ExpressionElem,
+  IfElem,
+  SwitchClauseElem,
+  SwitchElem,
+} from "../AbstractElems.ts";
 import { parseAttributeList } from "./ParseAttribute.ts";
 import {
   beginStatement,
   expectCompound,
-  finishBlockStatement,
+  finishStatement,
+  getStartWithAttributes,
   parseCompoundStatement,
 } from "./ParseStatement.ts";
 import {
-  attachAttributes,
+  attrsOrUndef,
   expect,
   expectExpression,
   throwParseError,
@@ -22,52 +29,67 @@ import type { ParsingContext } from "./ParsingContext.ts";
 export function parseIfStatement(
   ctx: ParsingContext,
   attributes?: AttributeElem[],
-): StatementElem | null {
+): IfElem | null {
   const startPos = beginStatement(ctx, "if", attributes);
   if (startPos === null) return null;
 
-  expectExpression(ctx, "Expected condition expression after 'if'");
-
+  const condition = expectExpression(ctx, "Expected condition after 'if'");
   const body = expectCompound(ctx, "Expected '{' after if condition");
-  ctx.addElem(body);
-  parseElseChain(ctx);
+  const elseBranch = parseElseChain(ctx);
 
-  return finishBlockStatement(startPos, ctx, attributes);
+  const params = { condition, body, else: elseBranch };
+  return finishStatement("if", startPos, ctx, params, attributes);
 }
 
 /** Grammar: switch_statement : attribute* 'switch' expression switch_body */
 export function parseSwitchStatement(
   ctx: ParsingContext,
   attributes?: AttributeElem[],
-): StatementElem | null {
+): SwitchElem | null {
   const startPos = beginStatement(ctx, "switch", attributes);
   if (startPos === null) return null;
 
-  expectExpression(ctx, "Expected expression after 'switch'");
-  expectSwitchClauses(ctx);
+  const selector = expectExpression(ctx, "Expected expression after 'switch'");
+  const { bodyAttributes, clauses } = expectSwitchClauses(ctx);
 
-  return finishBlockStatement(startPos, ctx, attributes);
+  const params = { selector, clauses, bodyAttributes };
+  return finishStatement("switch", startPos, ctx, params, attributes);
 }
 
 /**
  * Grammar: else_if_clause : 'else' 'if' expression compound_statement
  * Grammar: else_clause : 'else' compound_statement
+ *
+ * An else-if nests as an IfElem in the outer if's `else` field; a plain else is
+ * a BlockElem. Emit and the AST dump read these typed fields.
  */
-function parseElseChain(ctx: ParsingContext): void {
+function parseElseChain(ctx: ParsingContext): IfElem | BlockElem | undefined {
   const { stream } = ctx;
-  while (stream.matchText("else")) {
-    const elseIf = stream.matchText("if");
-    if (elseIf) {
-      expectExpression(ctx, "Expected expression after 'else if'");
-      const body = expectCompound(ctx, "Expected '{' after else if");
-      ctx.addElem(body);
-      continue;
-    }
-
-    const body = expectCompound(ctx, "Expected '{' after else");
-    ctx.addElem(body);
-    break;
+  const elseToken = stream.matchText("else");
+  if (!elseToken) return undefined;
+
+  if (stream.matchText("if")) {
+    const condition = expectExpression(
+      ctx,
+      "Expected expression after 'else if'",
+    );
+    const body = expectCompound(ctx, "Expected '{' after else if");
+    const elseBranch = parseElseChain(ctx);
+    const end = stream.checkpoint();
+    // Start at the 'else' keyword, not the pre-keyword position, so a comment
+    // before 'else if' falls in the gap and leads the branch (matches
+    // beginStatement); otherwise the nested if swallows it.
+    return {
+      kind: "if",
+      condition,
+      body,
+      else: elseBranch,
+      start: elseToken.span[0],
+      end,
+    };
   }
+
+  return expectCompound(ctx, "Expected '{' after else");
 }
 
 /**
@@ -76,54 +98,76 @@ function parseElseChain(ctx: ParsingContext): void {
  * Grammar: case_clause : 'case' case_selectors ':'? compound_statement
  * Grammar: default_alone_clause : 'default' ':'? compound_statement
  */
-function expectSwitchClauses(ctx: ParsingContext): void {
+function expectSwitchClauses(ctx: ParsingContext): {
+  bodyAttributes?: AttributeElem[];
+  clauses: SwitchClauseElem[];
+} {
   const { stream } = ctx;
-  parseAttributeList(ctx);
+  const bodyAttrs = parseAttributeList(ctx);
   expect(stream, "{", "switch expression");
+  const clauses: SwitchClauseElem[] = [];
   while (!stream.matchText("}")) {
-    const clauseStart = stream.checkpoint();
-    const clauseAttrs = parseAttributeList(ctx);
-    beginElem(
-      ctx,
-      "switch-clause",
-      clauseAttrs.length ? clauseAttrs : undefined,
-    );
+    clauses.push(parseSwitchClause(ctx));
+  }
+  return { bodyAttributes: attrsOrUndef(bodyAttrs), clauses };
+}
+
+/** Parse one 'case'/'default' clause (the keyword has not yet been consumed). */
+function parseSwitchClause(ctx: ParsingContext): SwitchClauseElem {
+  const { stream } = ctx;
+  const attrs = attrsOrUndef(parseAttributeList(ctx));
 
-    if (stream.matchText("case")) {
-      parseCaseSelectors(ctx);
-      parseCaseBody(ctx, "Expected '{' after case value");
-    } else if (stream.matchText("default")) {
-      parseCaseBody(ctx, "Expected '{' after 'default'");
-    } else {
-      throwParseError(stream, "Expected 'case', 'default', or '}' in switch");
-    }
-
-    const clauseElem = finishElem("switch-clause", clauseStart, ctx, {});
-    attachAttributes(clauseElem, clauseAttrs.length ? clauseAttrs : undefined);
-    ctx.addElem(clauseElem);
+  const caseTok = stream.matchText("case");
+  const keyword = caseTok ?? stream.matchText("default");
+  if (!keyword) {
+    throwParseError(stream, "Expected 'case', 'default', or '}' in switch");
   }
+  // The clause start is the keyword token, not any leading comment, so a
+  // preceding comment falls in the gap before it and attaches as leading.
+  const clauseStart = getStartWithAttributes(attrs, keyword.span[0]);
+
+  let selectors: (ExpressionElem | "default")[];
+  let body: BlockElem;
+  if (caseTok) {
+    selectors = parseCaseSelectors(ctx);
+    body = parseCaseBody(ctx, "Expected '{' after case value");
+  } else {
+    selectors = ["default"];
+    body = parseCaseBody(ctx, "Expected '{' after 'default'");
+  }
+
+  return finishStatement(
+    "switch-clause",
+    clauseStart,
+    ctx,
+    { selectors, body },
+    attrs,
+  );
 }
 
 /** Grammar: case_selectors : case_selector (',' case_selector)* ','? */
-function parseCaseSelectors(ctx: ParsingContext): void {
+function parseCaseSelectors(
+  ctx: ParsingContext,
+): (ExpressionElem | "default")[] {
   const { stream } = ctx;
-  expectExpression(ctx, "Expected expression after 'case'");
+  const selectors = [expectExpression(ctx, "Expected expression after 'case'")];
   while (stream.matchText(",")) {
-    expectExpression(ctx, "Expected expression after ',' in case values");
+    selectors.push(
+      expectExpression(ctx, "Expected expression after ',' in case values"),
+    );
   }
+  return selectors;
 }
 
 /**
  * Grammar: case_clause : 'case' case_selectors ':'? compound_statement
  * Grammar: default_alone_clause : 'default' ':'? compound_statement
  */
-function parseCaseBody(ctx: ParsingContext, errorMsg: string): void {
+function parseCaseBody(ctx: ParsingContext, errorMsg: string): BlockElem {
   ctx.stream.matchText(":");
 
-  const bodyAttrs = parseAttributeList(ctx);
-  const attrs = bodyAttrs.length > 0 ? bodyAttrs : undefined;
-
+  const attrs = attrsOrUndef(parseAttributeList(ctx));
   const body = parseCompoundStatement(ctx, attrs);
   if (!body) throwParseError(ctx.stream, errorMsg);
-  ctx.addElem(body);
+  return body;
 }

package/src/parse/ParseDirective.ts

@@ -7,8 +7,10 @@ import type {
   RequiresDirective,
 } from "../AbstractElems.ts";
 import { parseAttributeList } from "./ParseAttribute.ts";
+import { getStartWithAttributes } from "./ParseStatement.ts";
 import {
   attachAttributes,
+  attrsOrUndef,
   expect,
   expectWord,
   makeNameElem,
@@ -21,8 +23,7 @@ import type { WeslStream, WeslToken } from "./WeslStream.ts";
 export function parseDirective(ctx: ParsingContext): DirectiveElem | null {
   const { stream } = ctx;
   const startPos = stream.checkpoint();
-  const attributes = parseAttributeList(ctx);
-  const attrs = attributes.length > 0 ? attributes : undefined;
+  const attrs = attrsOrUndef(parseAttributeList(ctx));
 
   const result =
     parseExtensionDirective(ctx, "enable", attrs) ||
@@ -49,11 +50,6 @@ function parseExtensionDirective(
   return makeDirectiveElem(directive, token, stream, attributes);
 }
 
-function parseDirectiveName(ctx: ParsingContext): NameElem {
-  const nameToken = expectWord(ctx.stream, "Expected identifier in name list");
-  return makeNameElem(nameToken);
-}
-
 /**
  * Grammar: diagnostic_directive : 'diagnostic' diagnostic_control ';'
  * Grammar: diagnostic_control : '(' severity_control_name ',' diagnostic_rule_name ',' ? ')'
@@ -91,13 +87,18 @@ function parseDiagnosticDirective(
   return makeDirectiveElem(directive, token, stream, attributes);
 }
 
+function parseDirectiveName(ctx: ParsingContext): NameElem {
+  const nameToken = expectWord(ctx.stream, "Expected identifier in name list");
+  return makeNameElem(nameToken);
+}
+
 function makeDirectiveElem(
   directive: EnableDirective | RequiresDirective | DiagnosticDirective,
   token: WeslToken,
   stream: WeslStream,
   attributes?: AttributeElem[],
 ): DirectiveElem {
-  const start = attributes?.[0]?.start ?? token.span[0];
+  const start = getStartWithAttributes(attributes, token.span[0]);
   const end = stream.checkpoint();
   const elem: DirectiveElem = { kind: "directive", directive, start, end };
   attachAttributes(elem, attributes);

package/src/parse/ParseDoBlock.ts

@@ -0,0 +1,63 @@
+import type { AttributeElem, DoBlockElem } from "../AbstractElems.ts";
+import type { Scope } from "../Scope.ts";
+import { parseFnParams } from "./ParseFn.ts";
+import { getStartWithAttributes, parseFunctionBody } from "./ParseStatement.ts";
+import {
+  attachAttributes,
+  expectWord,
+  makeNameElem,
+  throwParseError,
+} from "./ParseUtil.ts";
+import type { ParsingContext } from "./ParsingContext.ts";
+
+/**
+ * Grammar: do_block_decl : attribute* 'do' ident '(' param_list? ')' compound_statement
+ *
+ * `do` is a module-level declaration when the `doBlocks` extension is on;
+ * otherwise it stays a reserved word. The body is parsed structurally but
+ * inside a scope that is detached from the module scope graph, so its idents
+ * never reach bindIdents. do blocks are module-local, resolved later by AST
+ * name match.
+ */
+export function parseDoBlock(
+  ctx: ParsingContext,
+  attributes?: AttributeElem[],
+): DoBlockElem | null {
+  if (!ctx.options.weslExtensions?.doBlocks) return null;
+
+  const { stream } = ctx;
+  const doToken = stream.matchText("do");
+  if (!doToken) return null;
+
+  const startPos = getStartWithAttributes(attributes, doToken.span[0]);
+  const nameToken = expectWord(stream, "Expected identifier after 'do'");
+  const name = makeNameElem(nameToken);
+
+  const parentScope = ctx.currentScope();
+  ctx.pushScope();
+  const doScope = ctx.currentScope();
+
+  const params = parseFnParams(ctx);
+  const body = parseFunctionBody(ctx);
+  if (!body) throwParseError(stream, "Expected do block body");
+
+  ctx.popScope();
+  detachScope(parentScope, doScope);
+
+  const doBlock: DoBlockElem = {
+    kind: "do",
+    name,
+    params,
+    body,
+    start: startPos,
+    end: stream.checkpoint(),
+  };
+  attachAttributes(doBlock, attributes);
+  return doBlock;
+}
+
+/** Remove a child scope from its parent so bindIdents never traverses it. */
+function detachScope(parent: Scope, child: Scope): void {
+  const i = parent.contents.indexOf(child);
+  if (i >= 0) parent.contents.splice(i, 1);
+}

package/src/parse/ParseExpression.ts

@@ -26,7 +26,6 @@ import { parseIdent } from "./ParseIdent.ts";
 import { parseTemplateParams } from "./ParseType.ts";
 import {
   expect,
-  expectExpression,
   expectWord,
   makeNameElem,
   throwParseError,
@@ -145,10 +144,14 @@ function parseBinaryExpr(
     if (isBinaryOpInContext(nextToken, inTemplate)) {
       const nextPrec = getPrecedence(nextToken);
       if (nextPrec > precedence) {
-        const group = "unary" as const;
-        const left = right;
-        const args = { prec: nextPrec, left, group, condRef, inTemplate };
-        right = parseBinaryExpr(ctx, args).expr;
+        const rightArgs: BinaryExprArgs = {
+          prec: nextPrec,
+          left: right,
+          group: "unary",
+          condRef,
+          inTemplate,
+        };
+        right = parseBinaryExpr(ctx, rightArgs).expr;
       }
     }
 
@@ -196,7 +199,6 @@ function parseParenExpr(
   if (!expression) throwParseError(stream, "Expected expression after '('");
 
   const close = expect(stream, ")", "expression");
-
   const start = open.span[0];
   const end = close.span[1];
   return { kind: "parenthesized-expression", expression, start, end };
@@ -224,15 +226,13 @@ function parseTemplateElaboratedIdent(
   if (!ctx.stream.nextTemplateStartToken()) return refIdent;
 
   const templateParams = parseTemplateParams(ctx);
-  const typeRef: TypeRefElem = {
+  return {
     kind: "type",
     name: refIdent.ident,
     templateParams,
     start: refIdent.start,
     end: ctx.stream.checkpoint(),
-    contents: [],
   };
-  return typeRef;
 }
 
 /** Parse postfix operators: member access, indexing, function calls. */
@@ -282,7 +282,8 @@ function parseIndexAccess(
 ): ComponentExpression | null {
   const { stream } = ctx;
   if (!stream.matchText("[")) return null;
-  const indexExpr = expectExpression(ctx, "Expected expression in array index");
+  const indexExpr = parseExpression(ctx);
+  if (!indexExpr) throwParseError(stream, "Expected expression in array index");
   const closeBracket = expect(stream, "]", "array index");
   return makeComponentExpression(base, indexExpr, closeBracket.span[1]);
 }

package/src/parse/ParseFn.ts

@@ -1,18 +1,19 @@
 import type {
   AttributeElem,
-  DeclIdentElem,
   FnElem,
   FnParamElem,
-  GrammarElem,
-  StatementElem,
   TypeRefElem,
 } from "../AbstractElems.ts";
-import { beginElem, finishElem } from "./ContentsHelpers.ts";
 import { parseAttributeList } from "./ParseAttribute.ts";
-import { getStartWithAttributes, parseFunctionBody } from "./ParseStatement.ts";
+import {
+  finishStatement,
+  getStartWithAttributes,
+  parseFunctionBody,
+} from "./ParseStatement.ts";
 import { parseSimpleTypeRef } from "./ParseType.ts";
 import {
   attachAttributes,
+  attrsOrUndef,
   createDeclIdentElem,
   expect,
   expectWord,
@@ -69,13 +70,6 @@ export function parseFnDecl(
     returnAttributes,
     start: startPos,
     end: stream.checkpoint(),
-    contents: buildFnContents(
-      attributes,
-      declIdentElem,
-      params,
-      returnType,
-      body,
-    ),
   };
   attachAttributes(fnElem, attributes);
   linkDeclIdentElem(declIdentElem, fnElem);
@@ -83,7 +77,7 @@ export function parseFnDecl(
 }
 
 /** Grammar: '(' param_list? ')' where param_list : param ( ',' param )* ','? */
-function parseFnParams(ctx: ParsingContext): FnParamElem[] {
+export function parseFnParams(ctx: ParsingContext): FnParamElem[] {
   const { stream } = ctx;
   const params: FnParamElem[] = [];
 
@@ -115,37 +109,21 @@ function parseFnReturn(ctx: ParsingContext): {
   const returnType = parseSimpleTypeRef(ctx);
   if (!returnType) throwParseError(stream, "Expected type after '->'");
 
-  return { returnType, returnAttributes: attrs.length > 0 ? attrs : undefined };
-}
-
-/** Build contents array for function element */
-function buildFnContents(
-  attributes: AttributeElem[] | undefined,
-  decl: DeclIdentElem,
-  params: FnParamElem[],
-  returnType: TypeRefElem | undefined,
-  body: StatementElem,
-): GrammarElem[] {
-  const base = returnType
-    ? [decl, ...params, returnType, body]
-    : [decl, ...params, body];
-  return attributes?.length ? [...attributes, ...base] : base;
+  return { returnType, returnAttributes: attrsOrUndef(attrs) };
 }
 
 /** Grammar: param : attribute* optionally_typed_ident */
 function parseFnParam(ctx: ParsingContext): FnParamElem | null {
-  const attributes = parseAttributeList(ctx);
+  const attrs = parseAttributeList(ctx);
   if (ctx.stream.peek()?.kind !== "word") return null;
+  const attributes = attrsOrUndef(attrs);
 
-  beginElem(ctx, "param", attributes.length ? attributes : undefined);
   const name = parseTypedDecl(ctx, false);
   if (!name)
     throw new Error("Unexpected: peek succeeded but parseTypedDecl failed");
-  ctx.addElem(name);
 
   const startPos = getStartWithAttributes(attributes, name.start);
-  const elem = finishElem("param", startPos, ctx, { name });
+  const elem = finishStatement("param", startPos, ctx, { name }, attributes);
   linkDeclIdent(name, elem);
-  attachAttributes(elem, attributes.length > 0 ? attributes : undefined);
   return elem;
 }

package/src/parse/ParseGlobalVar.ts

@@ -2,19 +2,20 @@ import type {
   AliasElem,
   AttributeElem,
   ConstAssertElem,
+  ExpressionElem,
   GlobalVarElem,
+  NameElem,
 } from "../AbstractElems.ts";
-import { beginElem, finishElem } from "./ContentsHelpers.ts";
-import { getStartWithAttributes } from "./ParseStatement.ts";
+import { finishStatement, getStartWithAttributes } from "./ParseStatement.ts";
 import { parseSimpleTypeRef } from "./ParseType.ts";
 import {
-  attachAttributes,
   createDeclIdentElem,
   expect,
   expectExpression,
   expectWord,
   linkDeclIdent,
   linkDeclIdentElem,
+  makeNameElem,
   throwParseError,
 } from "./ParseUtil.ts";
 import { parseTypedDecl } from "./ParseValueDeclaration.ts";
@@ -34,24 +35,28 @@ export function parseGlobalVarDecl(
 
   const startPos = getStartWithAttributes(attributes, varToken.span[0]);
   ctx.pushScope("partial");
-  beginElem(ctx, "gvar", attributes);
 
-  skipTemplateList(ctx);
+  const template = parseTemplateList(ctx);
 
   const typedDecl = parseTypedDecl(ctx);
   if (!typedDecl) throwParseError(stream, "Expected identifier after 'var'");
-  ctx.addElem(typedDecl);
 
+  let init: ExpressionElem | undefined;
   if (stream.matchText("=")) {
-    expectExpression(ctx);
+    init = expectExpression(ctx);
   }
   expect(stream, ";", "var declaration");
 
   typedDecl.decl.ident.dependentScope = ctx.currentScope();
   ctx.popScope();
 
-  const varElem = finishElem("gvar", startPos, ctx, { name: typedDecl });
-  attachAttributes(varElem, attributes);
+  const varElem = finishStatement(
+    "gvar",
+    startPos,
+    ctx,
+    { name: typedDecl, template, init },
+    attributes,
+  );
   linkDeclIdent(typedDecl, varElem);
   return varElem;
 }
@@ -66,12 +71,10 @@ export function parseAliasDecl(
   if (!aliasToken) return null;
 
   const startPos = getStartWithAttributes(attributes, aliasToken.span[0]);
-  beginElem(ctx, "alias", attributes);
 
   const nameToken = expectWord(stream, "Expected identifier after 'alias'");
 
   const declIdentElem = createDeclIdentElem(ctx, nameToken, true);
-  ctx.addElem(declIdentElem);
   ctx.saveIdent(declIdentElem.ident);
 
   expect(stream, "=", "alias name");
@@ -80,18 +83,19 @@ export function parseAliasDecl(
   const typeRef = parseSimpleTypeRef(ctx);
   if (!typeRef)
     throwParseError(stream, "Expected type after '=' in alias declaration");
-  ctx.addElem(typeRef);
 
   declIdentElem.ident.dependentScope = ctx.currentScope();
   ctx.popScope();
 
   expect(stream, ";", "alias declaration");
 
-  const aliasElem = finishElem("alias", startPos, ctx, {
-    name: declIdentElem,
-    typeRef,
-  });
-  attachAttributes(aliasElem, attributes);
+  const aliasElem = finishStatement(
+    "alias",
+    startPos,
+    ctx,
+    { name: declIdentElem, typeRef },
+    attributes,
+  );
   linkDeclIdentElem(declIdentElem, aliasElem);
   return aliasElem;
 }
@@ -105,27 +109,32 @@ export function parseConstAssert(
   if (!assertToken) return null;
 
   const startPos = getStartWithAttributes(attributes, assertToken.span[0]);
-  beginElem(ctx, "assert", attributes);
-  expectExpression(ctx);
+  const expression = expectExpression(ctx);
   expect(ctx.stream, ";", "const_assert expression");
 
-  const elem = finishElem("assert", startPos, ctx, {});
-  attachAttributes(elem, attributes);
-  return elem;
+  return finishStatement("assert", startPos, ctx, { expression }, attributes);
 }
 
-/** Skip optional template list (e.g., <storage, read_write>). */
-export function skipTemplateList(ctx: ParsingContext): void {
+/**
+ * Parse an optional var template list `<storage, read_write>`. The entries are
+ * predeclared enumerants (address space / access mode), not user idents, so they
+ * are captured as unbound NameElems.
+ */
+export function parseTemplateList(ctx: ParsingContext): NameElem[] | undefined {
   const { stream } = ctx;
-  if (!stream.nextTemplateStartToken()) return;
+  if (!stream.nextTemplateStartToken()) return undefined;
 
+  const names: NameElem[] = [];
   while (true) {
     const next = stream.peek();
     if (!next) throwParseError(stream, "Unclosed template in var declaration");
     if (next.text.startsWith(">")) {
       stream.nextTemplateEndToken();
-      return;
+      return names;
     }
-    stream.nextToken();
+    const word = stream.matchKind("word");
+    if (word) names.push(makeNameElem(word));
+    else if (!stream.matchText(","))
+      throwParseError(stream, "Expected ',' or '>' in var template list");
   }
 }

package/src/parse/ParseIdent.ts

@@ -56,11 +56,10 @@ export function parseIdent(
 
   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);
-  }
+  // conditionRef idents (@if/@elif) stay out of the scope tree entirely.
+  // The RefIdentElem is never added to container contents - it lives only
+  // inside the expression tree built by parseExpression.
+  if (!conditionRef) ctx.saveIdent(ident);
 
   return refIdentElem;
 }