@weborigami/language 0.0.64 → 0.0.65-beta.2

package/src/compiler/parserHelpers.js

@@ -2,6 +2,17 @@ import * as ops from "../runtime/ops.js";
 
 // Parser helpers
 
+/**
+ * If a parse result is an object that will be evaluated at runtime, attach the
+ * location of the source code that produced it for debugging and error messages.
+ */
+export function annotate(parseResult, location) {
+  if (typeof parseResult === "object" && parseResult !== null) {
+    parseResult.location = location;
+  }
+  return parseResult;
+}
+
 export function makeArray(entries) {
   let currentEntries = [];
   const spreads = [];
@@ -34,18 +45,45 @@ export function makeArray(entries) {
   }
 }
 
+/**
+ * @typedef {import("../../index.ts").Code} Code
+ *
+ * @param {Code} target
+ * @param {Code[]} chain
+ * @returns
+ */
 export function makeFunctionCall(target, chain) {
   let value = target;
+  const source = target.location.source;
   // The chain is an array of arguments (which are themselves arrays). We
   // successively apply the top-level elements of that chain to build up the
   // function composition.
+  let start = target.location.start;
+  let end = target.location.end;
   for (const args of chain) {
-    if (args[0] === ops.traverse) {
-      value = [ops.traverse, value, ...args.slice(1)];
-    } else {
-      value = [value, ...args];
+    /** @type {Code} */
+    let fnCall;
+
+    // @ts-ignore
+    fnCall =
+      args[0] === ops.traverse
+        ? [ops.traverse, value, ...args.slice(1)]
+        : [value, ...args];
+
+    // Create a location spanning the newly-constructed function call.
+    if (args instanceof Array) {
+      if (args.location) {
+        end = args.location.end;
+      } else {
+        throw "Internal parser error: no location for function call argument";
+      }
     }
+
+    fnCall.location = { start, source, end };
+
+    value = fnCall;
   }
+
   return value;
 }
 

package/src/runtime/evaluate.js

@@ -88,7 +88,7 @@ export default async function evaluate(code) {
       if (!result[scopeSymbol]) {
         Object.defineProperty(result, scopeSymbol, {
           get() {
-            return scope(result).trees;
+            return scope(this).trees;
           },
           enumerable: false,
         });

package/src/runtime/expressionFunction.js

@@ -5,19 +5,20 @@ import { evaluate } from "./internal.js";
 /**
  * Given parsed Origami code, return a function that executes that code.
  *
- * @param {import("../../index.js").Code} code - parsed Origami code
+ * @param {import("../../index.js").ParseResult} parsed - parsed Origami expression
  * @param {string} [name] - optional name of the function
  */
-export function createExpressionFunction(code, name) {
+export function createExpressionFunction(parsed, name) {
   /** @this {AsyncTree|null} */
   async function fn() {
-    return evaluate.call(this, code);
+    return evaluate.call(this, parsed);
   }
   if (name) {
     Object.defineProperty(fn, "name", { value: name });
   }
-  fn.code = code;
-  fn.toString = () => code.source?.text;
+  fn.code = parsed;
+  fn.toString = () =>
+    parsed instanceof Array ? parsed.location.source.text : parsed;
   return fn;
 }
 

package/test/compiler/parse.test.js

@@ -112,7 +112,7 @@ describe("Origami parser", () => {
     // Single slash at start of something = absolute file path
     assertParse("expression", "/path", [[ops.filesRoot], "path"]);
     // Consecutive slashes at start of something = comment
-    assertParse("expression", "path //comment", [ops.scope, "path"]);
+    assertParse("expression", "path //comment", [ops.scope, "path"], false);
   });
 
   test("functionComposition", () => {
@@ -450,6 +450,7 @@ describe("Origami parser", () => {
     assertParse("string", `"foo\\"s bar"`, `foo"s bar`);
     assertParse("string", `'bar\\'s baz'`, `bar's baz`);
     assertParse("string", `«string»`, "string");
+    assertParse("string", `"\\0\\b\\f\\n\\r\\t\\v"`, "\0\b\f\n\r\t\v");
   });
 
   test("templateDocument", () => {
@@ -519,9 +520,24 @@ describe("Origami parser", () => {
   });
 });
 
-function assertParse(startRule, source, expected) {
-  /** @type {any} */
-  const parseResult = parse(source, { grammarSource: source, startRule });
+function assertParse(startRule, source, expected, checkLocation = true) {
+  const parseResult = parse(source, {
+    grammarSource: { text: source },
+    startRule,
+  });
+
+  // Verify that the parser returned a `location` property and that it spans the
+  // entire source. We skip this check in cases where the source starts or ends
+  // with a comment; the parser will strip those.
+  if (checkLocation && parseResult instanceof Array) {
+    assert(parseResult.location);
+    const resultSource = parseResult.location.source.text.slice(
+      parseResult.location.start.offset,
+      parseResult.location.end.offset
+    );
+    assert.equal(resultSource, source.trim());
+  }
+
   const actual = stripLocations(parseResult);
   assert.deepEqual(actual, expected);
 }