wesl 0.6.0-pre2

package/src/debug/ASTtoString.ts

@@ -0,0 +1,149 @@
+import { AbstractElem, ModuleElem } from "../AbstractElems.ts";
+import { importToString } from "./ImportToString.ts";
+import { LineWrapper } from "./LineWrapper.ts";
+
+export function astToString(elem: AbstractElem, indent = 0): string {
+  const { kind, contents } = elem as ModuleElem;
+  const str = new LineWrapper(indent);
+  str.add(kind);
+  addElemFields(elem, str);
+  let childStrings: string[] = [];
+  if (contents) {
+    childStrings = contents.map(e => astToString(e, indent + 2));
+  }
+  if (childStrings.length) {
+    str.nl();
+    str.addBlock(childStrings.join("\n"), false);
+  }
+
+  return str.result;
+}
+
+export function elemToString(elem: AbstractElem): string {
+  const { kind } = elem as ModuleElem;
+  const str = new LineWrapper();
+  str.add(kind);
+  addElemFields(elem, str);
+  let childStrings: string[] = [];
+  if (childStrings.length) {
+    str.nl();
+    str.addBlock(childStrings.join("\n"), false);
+  }
+  return str.result;
+}
+
+function addElemFields(elem: AbstractElem, str: LineWrapper): void {
+  addTextFields(elem, str) ||
+    addVarishFields(elem, str) ||
+    addStructFields(elem, str) ||
+    addNameFields(elem, str) ||
+    addFnFields(elem, str) ||
+    addAliasFields(elem, str) ||
+    addImport(elem, str) ||
+    addRefIdent(elem, str) ||
+    addDeclIdent(elem, str);
+}
+
+function addVarishFields(
+  elem: AbstractElem,
+  str: LineWrapper,
+): true | undefined {
+  const { kind } = elem;
+  if (
+    kind === "var" ||
+    kind === "gvar" ||
+    kind === "const" ||
+    kind === "override"
+  ) {
+    str.add(" " + elem.name.ident.originalName);
+    if (elem.typeRef) {
+      str.add(":" + elem.typeRef.ident.originalName);
+    }
+    return true;
+  }
+}
+
+function addTextFields(
+  elem: AbstractElem,
+  str: LineWrapper,
+): true | undefined {
+  if (elem.kind === "text") {
+    const { srcModule, start, end } = elem;
+    str.add(` '${srcModule.src.slice(start, end)}'`);
+    return true;
+  }
+}
+
+function addRefIdent(elem: AbstractElem, str: LineWrapper): true | undefined {
+  if (elem.kind === "ref") {
+    str.add(" " + elem.ident.originalName);
+    return true;
+  }
+}
+
+function addDeclIdent(elem: AbstractElem, str: LineWrapper): true | undefined {
+  if (elem.kind === "decl") {
+    str.add(" %" + elem.ident.originalName);
+    return true;
+  }
+}
+
+function addAliasFields(
+  elem: AbstractElem,
+  str: LineWrapper,
+): true | undefined {
+  if (elem.kind === "alias") {
+    const { name, typeRef } = elem;
+    const prefix = name.ident.kind === "decl" ? "%" : "";
+    str.add(" " + prefix + name.ident.originalName);
+    str.add("=" + typeRef.ident.originalName);
+    return true;
+  }
+}
+
+function addStructFields(
+  elem: AbstractElem,
+  str: LineWrapper,
+): true | undefined {
+  if (elem.kind === "struct") {
+    str.add(" " + elem.name.ident.originalName);
+    return true;
+  }
+}
+
+function addImport(elem: AbstractElem, str: LineWrapper): true | undefined {
+  if (elem.kind === "import") {
+    str.add(" " + importToString(elem.imports));
+    return true;
+  }
+}
+
+function addNameFields(
+  elem: AbstractElem,
+  str: LineWrapper,
+): true | undefined {
+  if (elem.kind === "name") {
+    str.add(" " + elem.name);
+    return true;
+  }
+}
+
+function addFnFields(elem: AbstractElem, str: LineWrapper): true | undefined {
+  if (elem.kind === "fn") {
+    const { name, params, returnType } = elem;
+    str.add(" " + name.ident.originalName);
+
+    str.add("(");
+    const paramStrs = params
+      .map(p => p.name.ident.originalName + ": " + p.typeRef.ident.originalName)
+      .join(", ");
+    str.add(paramStrs);
+    str.add(")");
+
+    if (returnType) {
+      str.add(" -> " + returnType.ident.originalName);
+    }
+
+    return true;
+  }
+}

package/src/debug/ImportToString.ts

@@ -0,0 +1,21 @@
+import { ImportTree, PathSegment, SegmentList, SimpleSegment } from "../ImportTree.ts";
+
+export function importToString(tree: ImportTree): string {
+  return tree.segments.map(s => segmentToString(s)).join("/");
+}
+
+function segmentToString(segment: PathSegment): string {
+  if (segment instanceof SimpleSegment) {
+    const { name, as, args } = segment;
+    const asMsg = as ? ` as ${as}` : "";
+    const argsMsg = args ? `(${args.join(", ")})` : "";
+    return `${name}${argsMsg}${asMsg}`;
+  }
+  if (segment instanceof SegmentList) {
+    return `{${segment.list.map(s => segmentToString(s)).join(", ")}}`;
+  }
+  if (segment instanceof ImportTree) {
+    return `(${importToString(segment)})`;
+  }
+  return `|unknown segment type ${(segment as any).constructor.name}|`;
+}

package/src/debug/LineWrapper.ts

@@ -0,0 +1,65 @@
+/** debug utility for constructing strings that wrap at a fixed column width
+ * text beyond the column width is wrapped to start on the next line
+ */
+export class LineWrapper {
+  #fragments: string[] = [];
+  #column = 0;
+  #spc: string;
+  #oneLine = true;
+  #isHanging = false;
+  #hangingSpc: string;
+
+  constructor(
+    readonly indent = 0,
+    readonly maxWidth = 60,
+    readonly hangingIndent = 2,
+  ) {
+    this.#spc = " ".repeat(indent);
+    this.#hangingSpc = " ".repeat(hangingIndent);
+  }
+
+  /** add a new line to the constructed string */
+  nl() {
+    this.#fragments.push("\n");
+    this.#column = 0;
+    this.#oneLine = false;
+    this.#isHanging = false;
+  }
+
+  /** add a string, wrapping to the next line if necessary */
+  add(s: string) {
+    if (this.#column + s.length > this.maxWidth) {
+      this.hangingNl();
+    }
+    if (this.#column === 0) {
+      this.#fragments.push(this.#spc);
+      if (this.#isHanging) {
+        this.#fragments.push(this.#hangingSpc);
+      }
+      this.#column = this.indent;
+    }
+    this.#fragments.push(s);
+    this.#column += s.length;
+  }
+
+  /** add a raw block of text with no wrapping */
+  addBlock(s: string, andNewLine = true) {
+    this.#fragments.push(s);
+    if (andNewLine) this.nl();
+  }
+
+  /** @return the constructed string */
+  get result(): string {
+    return this.#fragments.join("");
+  }
+
+  /** true if the result contains no newlines */
+  get oneLine(): boolean {
+    return this.#oneLine;
+  }
+
+  private hangingNl() {
+    this.nl();
+    this.#isHanging = true;
+  }
+}

package/src/debug/ScopeToString.ts

@@ -0,0 +1,51 @@
+import { LineWrapper } from "./LineWrapper.ts";
+import { Ident, Scope } from "../Scope.ts";
+
+/** A debugging print of the scope tree with identifiers in nested brackets */
+export function scopeToString(scope: Scope, indent = 0): string {
+  const { children } = scope;
+  let childStrings: string[] = [];
+  if (children.length)
+    childStrings = children.map(c => scopeToString(c, indent + 2));
+
+  // list of identifiers, with decls prefixed with '%'
+  const identStrings = scope.idents.map(({ kind, originalName }) => {
+    const prefix = kind === "decl" ? "%" : "";
+    return `${prefix}${originalName}`;
+  });
+
+  const str = new LineWrapper(indent);
+  str.add("{ ");
+
+  const last = identStrings.length - 1;
+  identStrings.forEach((s, i) => {
+    const element = i < last ? s + ", " : s;
+    str.add(element);
+  });
+
+  if (childStrings.length) {
+    str.nl();
+    str.addBlock(childStrings.join("\n"));
+  }
+
+  if (str.oneLine) {
+    str.add(" }");
+  } else {
+    if (!childStrings.length) str.nl();
+    str.add("}");
+  }
+
+  return str.result;
+}
+
+export function identToString(ident?: Ident): string {
+  if (!ident) return JSON.stringify(ident);
+  const { kind, originalName } = ident;
+  const idStr = ident.id ? `#${ident.id}` : "";
+  if (kind === "ref") {
+    const ref = identToString(ident.refersTo!);
+    return `${originalName} ${idStr} -> ${ref}`;
+  } else {
+    return `%${originalName} ${idStr} (${ident.mangledName})`;
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from "./debug/ASTtoString.js";
+export * from "./debug/ScopeToString.js";
+export * from "./Linker.js";
+export * from "./ParseWESL.js";
+export * from "./PathUtil.js";
+export * from "./Util.js";
+export * from "./WgslBundle.js";

package/src/test/ErrorLogging.test.ts

@@ -0,0 +1,14 @@
+import { expect, test } from "vitest";
+import { linkWithLog } from "./TestUtil.ts";
+
+test("unresolved identifier", () => {
+  const src = `
+    fn main() { x = 7; }
+    `;
+  const { log } = linkWithLog(src);
+  expect(log).toMatchInlineSnapshot(`
+    "unresolved identifier in file: ./test.wesl
+        fn main() { x = 7; }   Ln 2
+                    ^^"
+  `);
+});

package/src/test/Expression.test.ts

@@ -0,0 +1,22 @@
+import { eof, seq } from "mini-parse";
+import { expect, test } from "vitest";
+import { expression } from "../WESLGrammar.ts";
+import { testAppParse } from "./TestUtil.ts";
+
+test("parse number", () => {
+  const src = `3`;
+  const { parsed } = testAppParse(seq(expression, eof), src);
+  expect(parsed).not.toBeNull();
+});
+
+test("parse comparisons with && ||", () => {
+  const src = `a<3   &&   4>(5)`;
+  const { parsed } = testAppParse(seq(expression, eof), src);
+  expect(parsed).not.toBeNull();
+});
+
+test("parse vec templated type", () => {
+  const src = `vec2<f32>`;
+  const { parsed } = testAppParse(seq(expression, eof), src);
+  expect(parsed).not.toBeNull();
+});

package/src/test/FlattenTreeImport.test.ts

@@ -0,0 +1,56 @@
+import { expect, test } from "vitest";
+import {
+  ImportTree,
+  SegmentList,
+  SimpleSegment,
+} from "../ImportTree.ts";
+import { flattenTreeImport } from "../FlattenTreeImport.ts";
+
+test("complex tree import", () => {
+  const zap = new SimpleSegment("zap");
+  const foo = new SimpleSegment("foo", "bar"); // foo as bar
+  const doh = new SimpleSegment("doh");
+  const bib = new SimpleSegment("bib");
+  const bog = new SimpleSegment("bog");
+  const subtree = new ImportTree([bib, bog]);
+  const list = new SegmentList([foo, doh, subtree]);
+
+  const tree = new ImportTree([zap, list]);
+  const flattened = flattenTreeImport(tree);
+  expect(flattened).toMatchInlineSnapshot(`
+    [
+      {
+        "importPath": [
+          "zap",
+          "bar",
+        ],
+        "modulePath": [
+          "zap",
+          "foo",
+        ],
+      },
+      {
+        "importPath": [
+          "zap",
+          "doh",
+        ],
+        "modulePath": [
+          "zap",
+          "doh",
+        ],
+      },
+      {
+        "importPath": [
+          "zap",
+          "bib",
+          "bog",
+        ],
+        "modulePath": [
+          "zap",
+          "bib",
+          "bog",
+        ],
+      },
+    ]
+  `);
+});