wesl 0.6.49 → 0.7.1

package/src/ClickableError.ts

@@ -1,5 +1,5 @@
-import { srcLog, tracing } from "mini-parse";
 import type { DeclIdentElem, RefIdent, RefIdentElem } from "wesl";
+import { debug, srcLog } from "./Logging.ts";
 import { offsetToLineNumber } from "./Util.ts";
 import { encodeVlq } from "./vlq/vlq.ts";
 
@@ -26,6 +26,7 @@ export interface ClickableErrorParams {
 /** Throw an error with an embedded source map so that browser users can
  *  click on the error in the browser debug console and see the wesl source code.  */
 export function throwClickableError(params: ClickableErrorParams): void {
+  if (!debug) throw params.error; // skip source map generation in prod
   const { url, text, lineNumber, lineColumn, length, error } = params;
 
   // Based on https://stackoverflow.com/questions/65274147/sourceurl-for-css
@@ -87,7 +88,7 @@ export function throwClickableError(params: ClickableErrorParams): void {
       Error.stackTraceLimit = oldLimit;
     }
     error.message = "";
-    if (tracing) e.cause = error; // users don't want to see this, but WESL developers might
+    if (debug) e.cause = error; // users don't want to see this, but WESL developers might
     throw e;
   }
 }

package/src/Conditions.ts

@@ -74,8 +74,8 @@ function evaluateIfExpression(
     return value === "true";
   } else if (kind === "parenthesized-expression") {
     return evaluateIfExpression(expression.expression, conditions);
-  } else if (kind === "translate-time-feature") {
-    return conditions[expression.name] ?? false;
+  } else if (kind === "ref") {
+    return conditions[expression.ident.originalName] ?? false;
   } else {
     throw new Error(`unexpected @if expression ${JSON.stringify(expression)}`);
   }

package/src/LinkedWesl.ts

@@ -1,5 +1,5 @@
-import type { SrcMap } from "mini-parse";
 import { assertThatDebug } from "./Assertions.ts";
+import type { SrcMap } from "./SrcMap.ts";
 import { errorHighlight, offsetToLineNumber } from "./Util.ts";
 import type { WeslDevice } from "./WeslDevice";
 

package/src/Linker.ts

@@ -1,4 +1,3 @@
-import { type SrcMap, SrcMapBuilder, tracing } from "mini-parse";
 import type { AbstractElem, ModuleElem } from "./AbstractElems.ts";
 import {
   bindIdents,
@@ -6,6 +5,7 @@ import {
   type VirtualLibrarySet,
 } from "./BindIdents.ts";
 import { LinkedWesl } from "./LinkedWesl.ts";
+import { debug } from "./Logging.ts";
 import { lowerAndEmit } from "./LowerAndEmit.ts";
 import type { ManglerFn } from "./Mangler.ts";
 import {
@@ -16,6 +16,7 @@ import {
 } from "./ModuleResolver.ts";
 import type { WeslAST } from "./ParseWESL.ts";
 import type { Conditions, DeclIdent, SrcModule } from "./Scope.ts";
+import { type SrcMap, SrcMapBuilder } from "./SrcMap.ts";
 import { filterMap, mapValues } from "./Util.ts";
 import type { WeslBundle } from "./WeslBundle.ts";
 
@@ -129,7 +130,7 @@ export function _linkSync(params: LinkParams): SrcMap {
   const finalResolver =
     resolvers.length === 1 ? resolvers[0] : new CompositeResolver(resolvers);
 
-  return linkRegistry({ resolver: finalResolver, ...params });
+  return linkRegistry({ ...params, resolver: finalResolver });
 }
 
 function createLibraryResolvers(
@@ -246,7 +247,7 @@ function getRootModule(
 ): WeslAST {
   const rootAst = resolver.resolveModule(modulePath);
   if (!rootAst) {
-    if (tracing) {
+    if (debug) {
       console.log(
         `root module not found: ${modulePath} (from ${rootModuleName})`,
       );

package/src/LinkerUtil.ts

@@ -1,10 +1,10 @@
-import { srcLog } from "mini-parse";
 import type {
   AbstractElem,
   ContainerElem,
   DeclIdentElem,
   RefIdentElem,
 } from "./AbstractElems.ts";
+import { srcLog } from "./Logging.ts";
 
 export function visitAst(
   elem: AbstractElem,

package/src/Logging.ts

@@ -0,0 +1,165 @@
+import type { SrcMap, SrcWithPath } from "./SrcMap.ts";
+
+/** base logger (can be overridden to a capturing logger for tests) */
+export let log = console.log;
+
+/** enable debug assertions and verbose error messages (set false via bundler for smaller builds) */
+export const debug = true;
+
+/** enable user-facing validation like operator binding rules (set false via bundler for smaller builds) */
+export const validation = true;
+
+/** use temporary logger for tests */
+export function withLogger<T>(logFn: typeof console.log, fn: () => T): T {
+  const orig = log;
+  try {
+    log = logFn;
+    return fn();
+  } finally {
+    log = orig;
+  }
+}
+
+/** use temporary logger for async tests */
+export async function withLoggerAsync<T>(
+  logFn: typeof console.log,
+  fn: () => Promise<T>,
+): Promise<T> {
+  const orig = log;
+  try {
+    log = logFn;
+    return await fn();
+  } finally {
+    log = orig;
+  }
+}
+
+/**
+ * Log a message along with the source line and a caret indicating the error position.
+ * @param pos is the position in the source string, or if src is a SrcMap,
+ *   then pos is the position in the dest (e.g. preprocessed) text
+ */
+export function srcLog(
+  src: string | SrcMap,
+  pos: number | [number, number],
+  ...msgs: any[]
+): void {
+  if (typeof src === "string") {
+    logInternalSrc(log, src, pos, ...msgs);
+    return;
+  }
+  const { src: mappedSrc, positions } = mapSrcPositions(src, pos);
+  logInternalSrc(log, mappedSrc.text, positions, ...msgs);
+}
+
+interface SrcPositions {
+  positions: number | [number, number];
+  src: SrcWithPath;
+}
+
+function mapSrcPositions(
+  srcMap: SrcMap,
+  destPos: number | [number, number],
+): SrcPositions {
+  const srcPos = srcMap.mapPositions(...[destPos].flat());
+  const { src } = srcPos[0];
+
+  let positions: [number, number] | number;
+  if (srcPos[1]?.src?.path === src.path && srcPos[1]?.src?.text === src.text) {
+    positions = srcPos.map(p => p.position) as [number, number];
+  } else {
+    positions = srcPos[0].position;
+  }
+
+  return { src, positions };
+}
+
+function logInternalSrc(
+  logFn: typeof console.log,
+  src: string,
+  pos: number | [number, number],
+  ...msgs: any[]
+): void {
+  logFn(...msgs);
+  const { line, lineNum, linePos, linePos2 } = srcLine(src, pos);
+  logFn(line, `  Ln ${lineNum}`);
+  const caret = carets(linePos, linePos2);
+  logFn(caret);
+}
+
+function carets(linePos: number, linePos2?: number): string {
+  const indent = " ".repeat(linePos);
+  const numCarets = linePos2 ? linePos2 - linePos : 1;
+  const caretStr = "^".repeat(numCarets);
+  return indent + caretStr;
+}
+
+// map from src strings to line start positions
+const startCache = new Map<string, number[]>();
+
+interface SrcLine {
+  /** src line w/o newline */
+  line: string;
+  /** requested position relative to line start */
+  linePos: number;
+  /** requested position2 relative to line start */
+  linePos2?: number;
+  /** line number in the src (first line is #1) */
+  lineNum: number;
+}
+
+/** return the line in the src containing a given character position */
+export function srcLine(
+  src: string,
+  position: number | [number, number],
+): SrcLine {
+  let pos: number;
+  let pos2: number | undefined;
+  if (typeof position === "number") {
+    pos = position;
+  } else {
+    [pos, pos2] = position;
+  }
+  const starts = getStarts(src);
+
+  let start = 0;
+  let end = starts.length - 1;
+
+  // short circuit search if pos is after last line start
+  if (pos >= starts[end]) {
+    start = end;
+  }
+
+  // binary search to find start,end positions that surround provided pos
+  while (start + 1 < end) {
+    const mid = (start + end) >> 1;
+    if (pos >= starts[mid]) {
+      start = mid;
+    } else {
+      end = mid;
+    }
+  }
+
+  let linePos2: number | undefined;
+  if (pos2 !== undefined && pos2 >= starts[start] && pos2 < starts[end]) {
+    linePos2 = pos2 - starts[start];
+  }
+
+  // get line with possible trailing newline
+  const lineNl = src.slice(starts[start], starts[start + 1] || src.length);
+
+  // return line without trailing newline
+  const line = lineNl.slice(-1) === "\n" ? lineNl.slice(0, -1) : lineNl;
+
+  return { line, linePos: pos - starts[start], linePos2, lineNum: start + 1 };
+}
+
+/** return an array of the character positions of the start of each line in the src (cached) */
+function getStarts(src: string): number[] {
+  const found = startCache.get(src);
+  if (found) return found;
+  const starts = [...src.matchAll(/\n/g)].map(m => m.index! + 1);
+  starts.unshift(0);
+  startCache.set(src, starts);
+  return starts;
+}