@weborigami/language 0.3.3-jse.1 → 0.3.3-jse.3

package/src/runtime/ops.js

@@ -11,12 +11,11 @@ import {
   deepText,
   isUnpackable,
   scope as scopeFn,
-  setParent,
   text as templateFunctionTree,
 } from "@weborigami/async-tree";
 import os from "node:os";
-import { builtinReferenceError, scopeReferenceError } from "./errors.js";
 import expressionObject from "./expressionObject.js";
+import getHandlers from "./getHandlers.js";
 import { evaluate } from "./internal.js";
 import mergeTrees from "./mergeTrees.js";
 import OrigamiFiles from "./OrigamiFiles.js";
@@ -68,25 +67,35 @@ export function bitwiseXor(a, b) {
 addOpLabel(bitwiseXor, "«ops.bitwiseXor»");
 
 /**
- * Like ops.scope, but only searches for a builtin at the top of the scope
- * chain.
+ * Cache the value of the code for an external reference
  *
  * @this {AsyncTree|null}
+ * @param {any} cache
+ * @param {string} path
+ * @param {AnnotatedCode} code
  */
-export async function builtin(key) {
-  if (!this) {
-    throw new Error("Tried to get the scope of a null or undefined tree.");
+export async function cache(cache, path, code) {
+  if (path in cache) {
+    // Cache hit
+    return cache[path];
   }
 
-  const builtins = Tree.root(this);
-  const value = await builtins.get(key);
-  if (value === undefined) {
-    throw await builtinReferenceError(this, builtins, key);
-  }
+  // Don't await: might get another request for this before promise resolves
+  const promise = await evaluate.call(this, code);
+
+  // Save promise so another request will get the same promise
+  cache[path] = promise;
+
+  // Now wait for the value
+  const value = await promise;
+
+  // Update the cache with the actual value
+  cache[path] = value;
 
   return value;
 }
-addOpLabel(builtin, "«ops.builtin»");
+addOpLabel(cache, "«ops.cache»");
+cache.unevaluatedArgs = true;
 
 /**
  * JavaScript comma operator, returns the last argument.
@@ -123,27 +132,21 @@ export async function construct(constructor, ...args) {
 }
 
 /**
- * Construct a document object by invoking the body code (a lambda) and adding
- * the resulting text to the front data.
+ * Return the nth parent of the current tree
  *
- * @this {AsyncTree|null}
- * @param {any} frontData
- * @param {AnnotatedCode} bodyCode
+ * @this {AsyncTree|null|undefined}
  */
-export async function document(frontData, bodyCode) {
-  const context = new ObjectTree(frontData);
-  context.parent = this;
-  const bodyFn = await evaluate.call(context, bodyCode);
-  const body = await bodyFn();
-  const object = {
-    ...frontData,
-    "@text": body,
-  };
-  setParent(object, this);
-  return object;
-}
-addOpLabel(document, "«ops.document");
-document.unevaluatedArgs = true;
+export function context(n = 0) {
+  let tree = this;
+  for (let i = 0; i < n; i++) {
+    if (!tree) {
+      throw new Error("Internal error: couldn't find tree ancestor.");
+    }
+    tree = tree.parent;
+  }
+  return tree;
+}
+addOpLabel(context, "«ops.context»");
 
 export function division(a, b) {
   return a / b;
@@ -161,36 +164,27 @@ export function exponentiation(a, b) {
 addOpLabel(exponentiation, "«ops.exponentiation»");
 
 /**
- * Look up the given key as an external reference and cache the value for future
- * requests.
+ * Flatten the values of the given trees
  *
- * @this {AsyncTree|null}
+ * @param {...any} args
  */
-export async function external(path, code, cache) {
-  if (!this) {
-    throw new Error("Tried to get the scope of a null or undefined tree.");
-  }
-
-  if (path in cache) {
-    // Cache hit
-    return cache[path];
-  }
-
-  // Don't await: might get another request for this before promise resolves
-  const promise = evaluate.call(this, code);
-  // Save promise so another request will get the same promise
-  cache[path] = promise;
-
-  // Now wait for the value
-  const value = await promise;
-
-  // Update the cache with the actual value
-  cache[path] = value;
+export async function flat(...args) {
+  const arrays = await Promise.all(
+    args.map(async (arg) =>
+      arg instanceof Array || typeof arg !== "object"
+        ? arg
+        : await Tree.values(arg)
+    )
+  );
 
-  return value;
+  return arrays.flat();
 }
-addOpLabel(external, "«ops.external»");
-external.unevaluatedArgs = true;
+addOpLabel(flat, "«ops.flat»");
+
+/**
+ * This op is only used during parsing for an explicit to a global.
+ */
+export const global = new String("«global");
 
 /**
  * This op is only used during parsing. It signals to ops.object that the
@@ -215,28 +209,12 @@ addOpLabel(greaterThanOrEqual, "«ops.greaterThanOrEqual»");
  */
 export async function homeDirectory() {
   const tree = new OrigamiFiles(os.homedir());
-  tree.parent = this ? Tree.root(this) : null;
+  // Use the same handlers as the current tree
+  tree.handlers = getHandlers(this);
   return tree;
 }
 addOpLabel(homeDirectory, "«ops.homeDirectory»");
 
-/**
- * Search the parent's scope -- i.e., exclude the current tree -- for the given
- * key.
- *
- * @this {AsyncTree|null}
- * @param {*} key
- */
-export async function inherited(key) {
-  if (!this?.parent) {
-    return undefined;
-  }
-  const parentScope = scopeFn(this.parent);
-  const value = await parentScope.get(key);
-  return value;
-}
-addOpLabel(inherited, "«ops.inherited»");
-
 /**
  * Return a function that will invoke the given code.
  *
@@ -375,61 +353,12 @@ addOpLabel(logicalOr, "«ops.logicalOr»");
  * Merge the given trees. If they are all plain objects, return a plain object.
  *
  * @this {AsyncTree|null}
- * @param {AnnotatedCode[]} codes
+ * @param {any[]} trees
  */
-export async function merge(...codes) {
-  // First pass: evaluate the direct property entries in a single object
-  let treeSpreads = false;
-  const directEntries = [];
-  for (const code of codes) {
-    if (code[0] === object) {
-      directEntries.push(...code.slice(1));
-    } else {
-      treeSpreads = true;
-    }
-  }
-
-  const directObject = directEntries
-    ? await expressionObject(directEntries, this)
-    : null;
-  if (!treeSpreads) {
-    // No tree spreads, we're done
-    return directObject;
-  }
-
-  // If we have direct property entries, create a context for them. The
-  // `expressionObject` function will set the object's parent symbol to `this`.
-  // Tree.from will call the ObjectTree constructor, which will use that symbol
-  // to set the parent for the new tree to `this`.
-  const context = directObject ? Tree.from(directObject) : this;
-
-  // Second pass: evaluate the trees. For the trees which are direct property
-  // entries, we'll copy over the values we've already calculated. We can't
-  // reuse the `directObject` as is because in a merge we need to respect the
-  // order in which the properties are defined. Trees that aren't direct
-  // property entries are evaluated with the direct property entries in scope.
-  const trees = await Promise.all(
-    codes.map(async (code) => {
-      if (code[0] === object) {
-        // Using the code as reference, create a new object with the direct
-        // property values we've already calculated.
-        const object = {};
-        for (const [key] of code.slice(1)) {
-          // @ts-ignore directObject will always be defined
-          object[key] = directObject[key];
-        }
-        setParent(object, this);
-        return object;
-      } else {
-        return evaluate.call(context, code);
-      }
-    })
-  );
-
+export async function merge(...trees) {
   return mergeTrees.call(this, ...trees);
 }
 addOpLabel(merge, "«ops.merge»");
-merge.unevaluatedArgs = true;
 
 export function multiplication(a, b) {
   return a * b;
@@ -498,31 +427,28 @@ addOpLabel(remainder, "«ops.remainder»");
  *
  * @this {AsyncTree|null}
  */
-export async function rootDirectory(key) {
-  let tree = new OrigamiFiles("/");
-  // We set the builtins as the parent because logically the filesystem root is
-  // outside the project. This ignores the edge case where the project itself is
-  // the root of the filesystem and has a config file.
-  tree.parent = this ? Tree.root(this) : null;
-  return key ? tree.get(key) : tree;
+export async function rootDirectory() {
+  const tree = new OrigamiFiles("/");
+  // Use the same handlers as the current tree
+  tree.handlers = getHandlers(this);
+  return tree;
 }
 addOpLabel(rootDirectory, "«ops.rootDirectory»");
 
 /**
- * Look up the given key in the scope for the current tree.
+ * Return the scope of the current tree
  *
  * @this {AsyncTree|null}
+ * @param {AsyncTree|null} [context]
  */
-export async function scope(key) {
-  if (!this) {
-    throw new Error("Tried to get the scope of a null or undefined tree.");
+export async function scope(context) {
+  if (context === undefined) {
+    context = this;
   }
-  const scope = scopeFn(this);
-  const value = await scope.get(key);
-  if (value === undefined && key !== "undefined") {
-    throw await scopeReferenceError(scope, key);
+  if (!context) {
+    return null;
   }
-  return value;
+  return scopeFn(context);
 }
 addOpLabel(scope, "«ops.scope»");
 
@@ -586,11 +512,6 @@ export async function templateTree(strings, ...values) {
 }
 addOpLabel(templateTree, "«ops.templateTree»");
 
-/**
- * Traverse a path of keys through a tree.
- */
-export const traverse = Tree.traverseOrThrow;
-
 export function unaryMinus(a) {
   return -a;
 }

package/src/runtime/symbols.js

@@ -1,3 +1,4 @@
 export const codeSymbol = Symbol("code");
+export const configSymbol = Symbol("config");
 export const scopeSymbol = Symbol("scope");
 export const sourceSymbol = Symbol("source");

package/src/runtime/templateIndent.js

@@ -1,4 +1,4 @@
-import { text, toString, Tree } from "@weborigami/async-tree";
+import { deepText, toString, Tree } from "@weborigami/async-tree";
 
 const lastLineWhitespaceRegex = /\n(?<indent>[ \t]*)$/;
 
@@ -19,7 +19,7 @@ export default async function indent(strings, ...values) {
   }
   const { blockIndentations, strings: modifiedStrings } = modified;
   const valueTexts = await Promise.all(
-    values.map((value) => (Tree.isTreelike(value) ? text(value) : value))
+    values.map((value) => (Tree.isTreelike(value) ? deepText(value) : value))
   );
   return joinBlocks(modifiedStrings, valueTexts, blockIndentations);
 }

package/test/compiler/codeHelpers.js

@@ -13,7 +13,9 @@ export function assertCodeEqual(actual, expected) {
  * @returns {import("../../index.ts").AnnotatedCode}
  */
 export function createCode(array) {
-  const code = array;
+  const code = array.map((item) =>
+    item instanceof Array ? createCode(item) : item
+  );
   /** @type {any} */ (code).location = {
     end: 0,
     source: {

package/test/compiler/compile.test.js

@@ -1,8 +1,7 @@
-import { ObjectTree, symbols, Tree } from "@weborigami/async-tree";
+import { ObjectTree, 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 { assertCodeEqual } from "./codeHelpers.js";
 
 const shared = new ObjectTree({
@@ -20,16 +19,48 @@ describe("compile", () => {
   test("functionComposition", async () => {
     await assertCompile("greet()", "Hello, undefined!");
     await assertCompile("greet(name)", "Hello, Alice!");
+    await assertCompile("greet(name)", "Hello, Alice!", { mode: "jse" });
     await assertCompile("greet 'world'", "Hello, world!");
   });
 
-  test("tree", async () => {
-    const fn = compile.expression("{ message = greet(name) }");
-    const tree = await fn.call(null);
-    tree[symbols.parent] = shared;
-    assert.deepEqual(await Tree.plain(tree), {
+  test("angle bracket path", async () => {
+    await assertCompile("<name>", "Alice", { mode: "jse", target: shared });
+  });
+
+  test("object literal", async () => {
+    await assertCompile("{ message = greet(name) }", {
       message: "Hello, Alice!",
     });
+    await assertCompile(
+      "{ message = greet(name) }",
+      {
+        message: "Hello, Alice!",
+      },
+      { mode: "jse" }
+    );
+  });
+
+  test.skip("merge", async () => {
+    {
+      const scope = new ObjectTree({
+        more: {
+          b: 2,
+        },
+      });
+      const fn = compile.expression(`
+        {
+          a: 1
+          ...more
+          c: a
+        }
+      `);
+      const result = await fn.call(scope);
+      assert.deepEqual(await Tree.plain(result), {
+        a: 1,
+        b: 2,
+        c: 1,
+      });
+    }
   });
 
   test("number", async () => {
@@ -44,8 +75,8 @@ describe("compile", () => {
   });
 
   test("async object", async () => {
-    const fn = compile.expression("{ a: { b = name }}");
-    const object = await fn.call(shared);
+    const fn = compile.expression("{ a: { b = name }}", { globals: shared });
+    const object = await fn.call(null);
     assert.deepEqual(await object.a.b, "Alice");
   });
 
@@ -68,7 +99,7 @@ describe("compile", () => {
 
   test("tagged template string array is identical across calls", async () => {
     let saved;
-    const scope = new ObjectTree({
+    const globals = new ObjectTree({
       tag: (strings, ...values) => {
         assertCodeEqual(strings, ["Hello, ", "!"]);
         if (saved) {
@@ -79,29 +110,23 @@ describe("compile", () => {
         return strings[0] + values[0] + strings[1];
       },
     });
-    const program = compile.expression("=tag`Hello, ${_}!`");
-    const lambda = await program.call(scope);
+    const program = compile.expression("=tag`Hello, ${_}!`", { globals });
+    const lambda = await program.call(null);
     const alice = await lambda("Alice");
     assert.equal(alice, "Hello, Alice!");
     const bob = await lambda("Bob");
     assert.equal(bob, "Hello, Bob!");
   });
-
-  test("can apply a macro", async () => {
-    const literal = [ops.literal, 1];
-    const expression = `{ a: literal }`;
-    const fn = compile.expression(expression, {
-      macros: {
-        literal,
-      },
-    });
-    const code = fn.code;
-    assertCodeEqual(code, [ops.object, ["a", 1]]);
-  });
 });
 
-async function assertCompile(text, expected) {
-  const fn = compile.expression(text);
-  const result = await fn.call(shared);
+async function assertCompile(text, expected, options = {}) {
+  const mode = options.mode ?? "shell";
+  const fn = compile.expression(text, { globals: shared, mode });
+  // For shell mode, use globals as scope too
+  const target = options.target ?? mode === "shell" ? shared : null;
+  let result = await fn.call(target);
+  if (Tree.isTreelike(result)) {
+    result = await Tree.plain(result);
+  }
   assert.deepEqual(result, expected);
 }

package/test/compiler/optimize.test.js

@@ -1,42 +1,111 @@
+import { ObjectTree } from "@weborigami/async-tree";
 import { describe, test } from "node:test";
 import * as compile from "../../src/compiler/compile.js";
 import optimize from "../../src/compiler/optimize.js";
+import { markers } from "../../src/compiler/parserHelpers.js";
 import { ops } from "../../src/runtime/internal.js";
 import { assertCodeEqual, createCode } from "./codeHelpers.js";
 
 describe("optimize", () => {
-  test("optimize non-local ops.scope calls to ops.external", async () => {
-    const expression = `
-      (name) => {
-        a: 1
-        b: a            // local, should be left as ops.scope
-        c: elsewhere    // external, should be converted to ops.external
-        d: name         // local, should be left as ops.scope
-      }
-    `;
-    const fn = compile.expression(expression);
-    const code = fn.code;
-    assertCodeEqual(code, [
+  test("change local references to context references", async () => {
+    const expression = `(name) => {
+      a: name,
+      b: a
+    }`;
+    const expected = [
       ops.lambda,
       [[ops.literal, "name"]],
       [
         ops.object,
-        ["a", 1],
-        ["b", [ops.scope, "a"]],
-        ["c", [ops.external, "elsewhere", [ops.scope, "elsewhere"], {}]],
-        ["d", [ops.scope, "name"]],
+        ["a", [[ops.context, 1], "name"]],
+        ["b", [[ops.context], "a"]],
       ],
+    ];
+    await assertCompile(expression, expected);
+    await assertCompile(expression, expected, "jse");
+  });
+
+  test("when defining a property, avoid recursive references", async () => {
+    const expression = `{
+      name: "Alice",
+      user: {
+        name: name
+      }
+    }`;
+    const expected = [
+      ops.object,
+      ["name", "Alice"],
+      ["user", [ops.object, ["name", [[ops.context, 1], "name"]]]],
+    ];
+    await assertCompile(expression, expected);
+    await assertCompile(expression, expected, "jse");
+  });
+
+  test("cache shell non-local references to globals+scope calls", async () => {
+    // Compilation of `x/y/z.js`
+    const code = createCode([
+      markers.reference,
+      [ops.literal, "x/"],
+      [ops.literal, "y/"],
+      [ops.literal, "z.js"],
+    ]);
+    const globals = {};
+    const expected = [
+      ops.cache,
+      {},
+      "x/y/z.js",
+      [[ops.merge, globals, [ops.scope]], "x/", "y/", "z.js"],
+    ];
+    assertCodeEqual(optimize(code, { globals }), expected);
+  });
+
+  test("change jse non-local references to globals", async () => {
+    // Compilation of `x/y`
+    const code = createCode([
+      markers.reference,
+      [ops.literal, "x/"],
+      [ops.literal, "y"],
+    ]);
+    const globals = {};
+    const expected = [globals, "x/", "y"];
+    assertCodeEqual(optimize(code, { globals, mode: "jse" }), expected);
+  });
+
+  test("cache jse top-level scope references", async () => {
+    // Compilation of `x/y/z.js`
+    const code = createCode([
+      [ops.scope],
+      [ops.literal, "x/"],
+      [ops.literal, "y/"],
+      [ops.literal, "z.js"],
     ]);
+    const expected = [
+      ops.cache,
+      {},
+      "x/y/z.js",
+      [[ops.scope], "x/", "y/", "z.js"],
+    ];
+    assertCodeEqual(optimize(code, { mode: "jse" }), expected);
   });
 
-  test("optimize scope traversals with all literal keys", async () => {
-    // Compilation of `x/y.js`
+  test("cache jse deeper scope references", async () => {
+    // Compilation of `{ property: <x> }`
     const code = createCode([
-      ops.traverse,
-      [ops.scope, "x/"],
-      [ops.literal, "y.js"],
+      ops.object,
+      ["property", [[ops.scope], [ops.literal, "x"]]],
     ]);
-    const optimized = optimize(code);
-    assertCodeEqual(optimized, [ops.external, "x/y.js", code, {}]);
+    const expected = [
+      ops.object,
+      ["property", [ops.cache, {}, "x", [[ops.scope, [ops.context, 1]], "x"]]],
+    ];
+    assertCodeEqual(optimize(code, { mode: "jse" }), expected);
   });
 });
+
+async function assertCompile(expression, expected, mode = "shell") {
+  const parent = new ObjectTree({});
+  const globals = new ObjectTree({});
+  const fn = compile.expression(expression, { globals, mode, parent });
+  const actual = fn.code;
+  assertCodeEqual(actual, expected);
+}