@weborigami/language 0.0.70 → 0.0.71-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.0.70",
+  "version": "0.0.71-beta.1",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,8 @@
     "typescript": "5.6.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.70",
-    "@weborigami/types": "0.0.70",
+    "@weborigami/async-tree": "0.0.71-beta.1",
+    "@weborigami/types": "0.0.71-beta.1",
     "watcher": "2.3.1"
   },
   "scripts": {

package/src/compiler/compile.js

@@ -1,15 +1,20 @@
+import { trailingSlash } from "@weborigami/async-tree";
 import { createExpressionFunction } from "../runtime/expressionFunction.js";
+import { ops } from "../runtime/internal.js";
 import { parse } from "./parse.js";
 
 function compile(source, startRule) {
   if (typeof source === "string") {
     source = { text: source };
   }
-  const parseResult = parse(source.text, {
+  const code = parse(source.text, {
     grammarSource: source,
     startRule,
   });
-  const fn = createExpressionFunction(parseResult);
+  const cache = {};
+  const modified = cacheNonLocalScopeReferences(code, cache);
+  // const modified = code;
+  const fn = createExpressionFunction(modified);
   return fn;
 }
 
@@ -17,6 +22,63 @@ export function expression(source) {
   return compile(source, "expression");
 }
 
+// Given code containing ops.scope calls, upgrade them to ops.cache calls unless
+// they refer to local variables: variables defined by object literals or lambda
+// parameters.
+export function cacheNonLocalScopeReferences(code, cache, locals = {}) {
+  const [fn, ...args] = code;
+
+  let additionalLocalNames;
+  switch (fn) {
+    case ops.scope:
+      const key = args[0];
+      const normalizedKey = trailingSlash.remove(key);
+      if (locals[normalizedKey]) {
+        return code;
+      } else {
+        // Upgrade to cached scope lookup
+        const modified = [ops.cache, key, cache];
+        /** @type {any} */ (modified).location = code.location;
+        return modified;
+      }
+
+    case ops.lambda:
+      const parameters = args[0];
+      additionalLocalNames = parameters;
+      break;
+
+    case ops.object:
+      const entries = args;
+      additionalLocalNames = entries.map(([key]) => trailingSlash.remove(key));
+      break;
+  }
+
+  let updatedLocals = { ...locals };
+  if (additionalLocalNames) {
+    for (const key of additionalLocalNames) {
+      updatedLocals[key] = true;
+    }
+  }
+
+  const modified = code.map((child) => {
+    if (Array.isArray(child)) {
+      // Review: This currently descends into arrays that are not instructions,
+      // such as the parameters of a lambda. This should be harmless, but it'd
+      // be preferable to only descend into instructions. This would require
+      // surrounding ops.lambda parameters with ops.literal, and ops.object
+      // entries with ops.array.
+      return cacheNonLocalScopeReferences(child, cache, updatedLocals);
+    } else {
+      return child;
+    }
+  });
+
+  if (code.location) {
+    modified.location = code.location;
+  }
+  return modified;
+}
+
 export function templateDocument(source) {
   return compile(source, "templateDocument");
 }

package/src/compiler/origami.pegjs

@@ -209,7 +209,7 @@ integer "integer"
 // A lambda expression: `=foo()`
 lambda "lambda function"
   = "=" __ expr:expr {
-      return annotate([ops.lambda, null, expr], location());
+      return annotate([ops.lambda, ["_"], expr], location());
     }
 
 // A path that begins with a slash: `/foo/bar`
@@ -435,7 +435,7 @@ taggedTemplate
 // literal, but can contain backticks at the top level.
 templateDocument "template"
   = contents:templateDocumentContents {
-      return annotate([ops.lambda, null, contents], location());
+      return annotate([ops.lambda, ["_"], contents], location());
     }
 
 // Template documents can contain backticks at the top level.

package/src/compiler/parse.js

@@ -416,7 +416,7 @@ function peg$parse(input, options) {
       return annotate([ops.literal, parseInt(text())], location());
     };
   var peg$f26 = function(expr) {
-      return annotate([ops.lambda, null, expr], location());
+      return annotate([ops.lambda, ["_"], expr], location());
     };
   var peg$f27 = function(path) {
       return annotate(path ?? [], location());
@@ -500,7 +500,7 @@ function peg$parse(input, options) {
       return annotate(makeTemplate(tag, contents[0], contents[1]), location());
     };
   var peg$f60 = function(contents) {
-      return annotate([ops.lambda, null, contents], location());
+      return annotate([ops.lambda, ["_"], contents], location());
     };
   var peg$f61 = function(head, tail) {
       return annotate(makeTemplate(ops.template, head, tail), location());

package/src/runtime/extensions.js

@@ -8,6 +8,11 @@ import {
   trailingSlash,
 } from "@weborigami/async-tree";
 
+/** @typedef {import("../../index.ts").ExtensionHandler} ExtensionHandler */
+
+// Track extensions handlers for a given containing tree.
+const handlersForContainer = new Map();
+
 /**
  * If the given path ends in an extension, return it. Otherwise, return the
  * empty string.
@@ -38,18 +43,39 @@ export function extname(path) {
  * @param {string} extension
  */
 export async function getExtensionHandler(parent, extension) {
+  let handlers = handlersForContainer.get(parent);
+  if (handlers) {
+    if (handlers[extension]) {
+      return handlers[extension];
+    }
+  } else {
+    handlers = {};
+    handlersForContainer.set(parent, handlers);
+  }
+
   const handlerName = `${extension.slice(1)}_handler`;
   const parentScope = scope(parent);
-  /** @type {import("../../index.ts").ExtensionHandler} */
-  let extensionHandler = await parentScope?.get(handlerName);
-  if (isUnpackable(extensionHandler)) {
-    // The extension handler itself needs to be unpacked. E.g., if it's a
-    // buffer containing JavaScript file, we need to unpack it to get its
-    // default export.
-    // @ts-ignore
-    extensionHandler = await extensionHandler.unpack();
-  }
-  return extensionHandler;
+
+  /** @type {Promise<ExtensionHandler>} */
+  let handlerPromise = parentScope
+    ?.get(handlerName)
+    .then(async (extensionHandler) => {
+      if (isUnpackable(extensionHandler)) {
+        // The extension handler itself needs to be unpacked. E.g., if it's a
+        // buffer containing JavaScript file, we need to unpack it to get its
+        // default export.
+        // @ts-ignore
+        extensionHandler = await extensionHandler.unpack();
+      }
+      // Update cache with actual handler
+      handlers[extension] = extensionHandler;
+      return extensionHandler;
+    });
+
+  // Cache handler even if it's undefined so we don't look it up again
+  handlers[extension] = handlerPromise;
+
+  return handlerPromise;
 }
 
 /**
@@ -62,7 +88,7 @@ export async function getExtensionHandler(parent, extension) {
  * @param {any} key
  */
 export async function handleExtension(parent, value, key) {
-  if (isPacked(value) && isStringLike(key)) {
+  if (isPacked(value) && isStringLike(key) && value.unpack === undefined) {
     const hasSlash = trailingSlash.has(key);
     if (hasSlash) {
       key = trailingSlash.remove(key);
@@ -89,10 +115,10 @@ export async function handleExtension(parent, value, key) {
         const unpack = handler.unpack;
         if (unpack) {
           // Wrap the unpack function so its only called once per value.
-          let loaded;
+          let loadPromise;
           value.unpack = async () => {
-            loaded ??= await unpack(value, { key, parent });
-            return loaded;
+            loadPromise ??= unpack(value, { key, parent });
+            return loadPromise;
           };
         }
       }

package/src/runtime/ops.js

@@ -43,6 +43,25 @@ export async function array(...items) {
 }
 addOpLabel(array, "«ops.array»");
 
+/**
+ * Look up the given key in the scope for the current tree the first time
+ * the key is requested, holding on to the value for future requests.
+ *
+ * @this {AsyncTree|null}
+ */
+export async function cache(key, cache) {
+  if (key in cache) {
+    return cache[key];
+  }
+  // First save a promise for the value
+  const promise = scope.call(this, key);
+  cache[key] = promise;
+  const value = await promise;
+  // Now update with the actual value
+  cache[key] = value;
+  return value;
+}
+
 // The assign op is a placeholder for an assignment declaration.
 // It is only used during parsing -- it shouldn't be executed.
 export const assign = "«ops.assign»";
@@ -236,9 +255,6 @@ export function lambda(parameters, code) {
     return lambdaFnMap.get(code);
   }
 
-  // By default, the first input argument is named `_`.
-  parameters ??= ["_"];
-
   /** @this {AsyncTree|null} */
   async function invoke(...args) {
     // Add arguments and @recurse to scope.

package/test/compiler/compile.test.js

@@ -2,6 +2,8 @@ import { ObjectTree, symbols, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import * as compile from "../../src/compiler/compile.js";
+import { ops } from "../../src/runtime/internal.js";
+import { stripCodeLocations } from "./stripCodeLocations.js";
 
 const shared = new ObjectTree({
   greet: (name) => `Hello, ${name}!`,
@@ -82,6 +84,30 @@ describe("compile", () => {
     const bob = await templateFn.call(scope, "Bob");
     assert.equal(bob, "Hello, Bob!");
   });
+
+  test("converts non-local ops.scope calls to ops.cache", async () => {
+    const expression = `
+      (name) => {
+        a: 1
+        b: a            // local, should be left as ops.scope
+        c: nonLocal     // non-local, should be converted to ops.cache
+        d: name         // local, should be left as ops.scope
+      }
+    `;
+    const fn = compile.expression(expression);
+    const code = fn.code;
+    assert.deepEqual(stripCodeLocations(code), [
+      ops.lambda,
+      ["name"],
+      [
+        ops.object,
+        ["a", [ops.literal, 1]],
+        ["b", [ops.scope, "a"]],
+        ["c", [ops.cache, "nonLocal", {}]],
+        ["d", [ops.scope, "name"]],
+      ],
+    ]);
+  });
 });
 
 async function assertCompile(text, expected) {

package/test/compiler/parse.test.js

@@ -1,8 +1,8 @@
-import { isPlainObject } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import { parse } from "../../src/compiler/parse.js";
 import * as ops from "../../src/runtime/ops.js";
+import { stripCodeLocations } from "./stripCodeLocations.js";
 
 describe("Origami parser", () => {
   test("absoluteFilePath", () => {
@@ -63,7 +63,7 @@ describe("Origami parser", () => {
     ]);
     assertParse("expr", "fn =`x`", [
       [ops.scope, "fn"],
-      [ops.lambda, null, [ops.template, [ops.literal, ["x"]]]],
+      [ops.lambda, ["_"], [ops.template, [ops.literal, ["x"]]]],
     ]);
     assertParse("expr", "copy app(formulas), files 'snapshot'", [
       [ops.scope, "copy"],
@@ -80,7 +80,7 @@ describe("Origami parser", () => {
       [ops.scope, "@map"],
       [
         ops.lambda,
-        null,
+        ["_"],
         [
           ops.template,
           [ops.literal, ["<li>", "</li>"]],
@@ -271,12 +271,12 @@ describe("Origami parser", () => {
   test("lambda", () => {
     assertParse("lambda", "=message", [
       ops.lambda,
-      null,
+      ["_"],
       [ops.scope, "message"],
     ]);
     assertParse("lambda", "=`Hello, ${name}.`", [
       ops.lambda,
-      null,
+      ["_"],
       [
         ops.template,
         [ops.literal, ["Hello, ", "."]],
@@ -609,7 +609,7 @@ describe("Origami parser", () => {
   test("templateDocument", () => {
     assertParse("templateDocument", "hello${foo}world", [
       ops.lambda,
-      null,
+      ["_"],
       [
         ops.template,
         [ops.literal, ["hello", "world"]],
@@ -618,7 +618,7 @@ describe("Origami parser", () => {
     ]);
     assertParse("templateDocument", "Documents can contain ` backticks", [
       ops.lambda,
-      null,
+      ["_"],
       [ops.template, [ops.literal, ["Documents can contain ` backticks"]]],
     ]);
   });
@@ -648,7 +648,7 @@ describe("Origami parser", () => {
           [ops.scope, "people"],
           [
             ops.lambda,
-            null,
+            ["_"],
             [
               ops.template,
               [ops.literal, ["", ""]],
@@ -695,23 +695,6 @@ function assertParse(startRule, source, expected, checkLocation = true) {
     assert.equal(resultSource, source.trim());
   }
 
-  const actual = stripLocations(code);
+  const actual = stripCodeLocations(code);
   assert.deepEqual(actual, expected);
 }
-
-// For comparison purposes, strip the `location` property added by the parser.
-function stripLocations(parseResult) {
-  if (Array.isArray(parseResult)) {
-    return parseResult.map(stripLocations);
-  } else if (isPlainObject(parseResult)) {
-    const result = {};
-    for (const key in parseResult) {
-      if (key !== "location") {
-        result[key] = stripLocations(parseResult[key]);
-      }
-    }
-    return result;
-  } else {
-    return parseResult;
-  }
-}

package/test/compiler/stripCodeLocations.js

@@ -0,0 +1,18 @@
+import { isPlainObject } from "@weborigami/async-tree";
+
+// For comparison purposes, strip the `location` property added by the parser.
+export function stripCodeLocations(parseResult) {
+  if (Array.isArray(parseResult)) {
+    return parseResult.map(stripCodeLocations);
+  } else if (isPlainObject(parseResult)) {
+    const result = {};
+    for (const key in parseResult) {
+      if (key !== "location") {
+        result[key] = stripCodeLocations(parseResult[key]);
+      }
+    }
+    return result;
+  } else {
+    return parseResult;
+  }
+}

package/test/runtime/ops.test.js

@@ -5,6 +5,20 @@ import { describe, test } from "node:test";
 import { evaluate, ops } from "../../src/runtime/internal.js";
 
 describe("ops", () => {
+  test("ops.cache looks up a value in scope and memoizes it", async () => {
+    let count = 0;
+    const tree = new ObjectTree({
+      get count() {
+        return ++count;
+      },
+    });
+    const code = createCode([ops.cache, "count", {}]);
+    const result = await evaluate.call(tree, code);
+    assert.equal(result, 1);
+    const result2 = await evaluate.call(tree, code);
+    assert.equal(result2, 1);
+  });
+
   test("ops.concat concatenates tree value text", async () => {
     const scope = new ObjectTree({
       name: "world",
@@ -47,20 +61,13 @@ describe("ops", () => {
       message: "Hello",
     });
 
-    const code = createCode([ops.lambda, null, [ops.scope, "message"]]);
+    const code = createCode([ops.lambda, ["_"], [ops.scope, "message"]]);
 
     const fn = await evaluate.call(scope, code);
     const result = await fn.call(scope);
     assert.equal(result, "Hello");
   });
 
-  test("ops.lambda adds input to scope as `_`", async () => {
-    const code = createCode([ops.lambda, null, [ops.scope, "_"]]);
-    const fn = await evaluate.call(null, code);
-    const result = await fn("Hello");
-    assert.equal(result, "Hello");
-  });
-
   test("ops.lambda adds input parameters to scope", async () => {
     const code = createCode([
       ops.lambda,
@@ -73,7 +80,7 @@ describe("ops", () => {
   });
 
   test("ops.lambda function can reference itself with @recurse", async () => {
-    const code = createCode([ops.lambda, null, [ops.scope, "@recurse"]]);
+    const code = createCode([ops.lambda, ["_"], [ops.scope, "@recurse"]]);
     const fn = await evaluate.call(null, code);
     const result = await fn();
     // We're expecting the function to return itself, but testing recursion is