@weborigami/language 0.3.3-jse.3 → 0.3.3

package/src/runtime/ops.js

@@ -11,17 +11,17 @@ import {
   deepText,
   isUnpackable,
   scope as scopeFn,
-  text as templateFunctionTree,
+  setParent,
+  concat as treeConcat,
 } from "@weborigami/async-tree";
 import os from "node:os";
+import taggedTemplateIndent from "../../src/runtime/taggedTemplateIndent.js";
+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";
 import { codeSymbol } from "./symbols.js";
-import templateFunctionIndent from "./templateIndent.js";
-import templateFunctionStandard from "./templateStandard.js";
 
 function addOpLabel(op, label) {
   Object.defineProperty(op, "toString", {
@@ -67,35 +67,25 @@ export function bitwiseXor(a, b) {
 addOpLabel(bitwiseXor, "«ops.bitwiseXor»");
 
 /**
- * Cache the value of the code for an external reference
+ * Like ops.scope, but only searches for a builtin at the top of the scope
+ * chain.
  *
  * @this {AsyncTree|null}
- * @param {any} cache
- * @param {string} path
- * @param {AnnotatedCode} code
  */
-export async function cache(cache, path, code) {
-  if (path in cache) {
-    // Cache hit
-    return cache[path];
+export async function builtin(key) {
+  if (!this) {
+    throw new Error("Tried to get the scope of a null or undefined tree.");
   }
 
-  // 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;
+  const builtins = Tree.root(this);
+  const value = await builtins.get(key);
+  if (value === undefined) {
+    throw await builtinReferenceError(this, builtins, key);
+  }
 
   return value;
 }
-addOpLabel(cache, "«ops.cache»");
-cache.unevaluatedArgs = true;
+addOpLabel(builtin, "«ops.builtin»");
 
 /**
  * JavaScript comma operator, returns the last argument.
@@ -115,7 +105,7 @@ addOpLabel(comma, "«ops.comma»");
  * @param {any[]} args
  */
 export async function concat(...args) {
-  return deepText.call(this, args);
+  return treeConcat.call(this, args);
 }
 addOpLabel(concat, "«ops.concat»");
 
@@ -124,29 +114,28 @@ export async function conditional(condition, truthy, falsy) {
   return value instanceof Function ? await value() : value;
 }
 
-export async function construct(constructor, ...args) {
-  if (isUnpackable(constructor)) {
-    constructor = await constructor.unpack();
-  }
-  return Reflect.construct(constructor, args);
-}
-
 /**
- * Return the nth parent of the current tree
+ * Construct a document object by invoking the body code (a lambda) and adding
+ * the resulting text to the front data.
  *
- * @this {AsyncTree|null|undefined}
+ * @this {AsyncTree|null}
+ * @param {any} frontData
+ * @param {AnnotatedCode} bodyCode
  */
-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 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 division(a, b) {
   return a / b;
@@ -164,27 +153,36 @@ export function exponentiation(a, b) {
 addOpLabel(exponentiation, "«ops.exponentiation»");
 
 /**
- * Flatten the values of the given trees
+ * Look up the given key as an external reference and cache the value for future
+ * requests.
  *
- * @param {...any} args
+ * @this {AsyncTree|null}
  */
-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)
-    )
-  );
+export async function external(path, code, cache) {
+  if (!this) {
+    throw new Error("Tried to get the scope of a null or undefined tree.");
+  }
 
-  return arrays.flat();
-}
-addOpLabel(flat, "«ops.flat»");
+  if (path in cache) {
+    // Cache hit
+    return cache[path];
+  }
 
-/**
- * This op is only used during parsing for an explicit to a global.
- */
-export const global = new String("«global");
+  // 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;
+
+  return value;
+}
+addOpLabel(external, "«ops.external»");
+external.unevaluatedArgs = true;
 
 /**
  * This op is only used during parsing. It signals to ops.object that the
@@ -209,12 +207,28 @@ addOpLabel(greaterThanOrEqual, "«ops.greaterThanOrEqual»");
  */
 export async function homeDirectory() {
   const tree = new OrigamiFiles(os.homedir());
-  // Use the same handlers as the current tree
-  tree.handlers = getHandlers(this);
+  tree.parent = this ? Tree.root(this) : null;
   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.
  *
@@ -353,12 +367,61 @@ addOpLabel(logicalOr, "«ops.logicalOr»");
  * Merge the given trees. If they are all plain objects, return a plain object.
  *
  * @this {AsyncTree|null}
- * @param {any[]} trees
+ * @param {AnnotatedCode[]} codes
  */
-export async function merge(...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);
+      }
+    })
+  );
+
   return mergeTrees.call(this, ...trees);
 }
 addOpLabel(merge, "«ops.merge»");
+merge.unevaluatedArgs = true;
 
 export function multiplication(a, b) {
   return a * b;
@@ -409,14 +472,6 @@ export async function object(...entries) {
 addOpLabel(object, "«ops.object»");
 object.unevaluatedArgs = true;
 
-export function optionalTraverse(treelike, key) {
-  if (!treelike) {
-    return undefined;
-  }
-  return Tree.traverseOrThrow(treelike, key);
-}
-addOpLabel(optionalTraverse, "«ops.optionalTraverse");
-
 export function remainder(a, b) {
   return a % b;
 }
@@ -427,28 +482,31 @@ addOpLabel(remainder, "«ops.remainder»");
  *
  * @this {AsyncTree|null}
  */
-export async function rootDirectory() {
-  const tree = new OrigamiFiles("/");
-  // Use the same handlers as the current tree
-  tree.handlers = getHandlers(this);
-  return tree;
+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;
 }
 addOpLabel(rootDirectory, "«ops.rootDirectory»");
 
 /**
- * Return the scope of the current tree
+ * Look up the given key in the scope for the current tree.
  *
  * @this {AsyncTree|null}
- * @param {AsyncTree|null} [context]
  */
-export async function scope(context) {
-  if (context === undefined) {
-    context = this;
+export async function scope(key) {
+  if (!this) {
+    throw new Error("Tried to get the scope of a null or undefined tree.");
   }
-  if (!context) {
-    return null;
+  const scope = scopeFn(this);
+  const value = await scope.get(key);
+  if (value === undefined && key !== "undefined") {
+    throw await scopeReferenceError(scope, key);
   }
-  return scopeFn(context);
+  return value;
 }
 addOpLabel(scope, "«ops.scope»");
 
@@ -489,28 +547,25 @@ export function subtraction(a, b) {
 addOpLabel(subtraction, "«ops.subtraction»");
 
 /**
- * Apply the tree indent tagged template function.
+ * Apply the default tagged template function.
  */
-export async function templateIndent(strings, ...values) {
-  return templateFunctionIndent(strings, ...values);
+export async function template(strings, ...values) {
+  return deepText(strings, ...values);
 }
-addOpLabel(templateIndent, "«ops.templateIndent»");
+addOpLabel(template, "«ops.template»");
 
 /**
- * Apply the default tagged template function.
+ * Apply the tagged template indent function.
  */
-export function templateStandard(strings, ...values) {
-  return templateFunctionStandard(strings, ...values);
+export async function templateIndent(strings, ...values) {
+  return taggedTemplateIndent(strings, ...values);
 }
-addOpLabel(templateStandard, "«ops.templateStandard»");
+addOpLabel(templateIndent, "«ops.templateIndent");
 
 /**
- * Apply the tree tagged template function.
+ * Traverse a path of keys through a tree.
  */
-export async function templateTree(strings, ...values) {
-  return templateFunctionTree(strings, ...values);
-}
-addOpLabel(templateTree, "«ops.templateTree»");
+export const traverse = Tree.traverseOrThrow;
 
 export function unaryMinus(a) {
   return -a;

package/src/runtime/symbols.js

@@ -1,4 +1,3 @@
 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 → taggedTemplateIndent.js}

@@ -1,4 +1,4 @@
-import { deepText, toString, Tree } from "@weborigami/async-tree";
+import { concat, 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) ? deepText(value) : value))
+    values.map((value) => (Tree.isTreelike(value) ? concat(value) : value))
   );
   return joinBlocks(modifiedStrings, valueTexts, blockIndentations);
 }

package/test/compiler/codeHelpers.js

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

package/test/compiler/compile.test.js

@@ -1,7 +1,8 @@
-import { ObjectTree, Tree } from "@weborigami/async-tree";
+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 { assertCodeEqual } from "./codeHelpers.js";
 
 const shared = new ObjectTree({
@@ -19,48 +20,16 @@ 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("angle bracket path", async () => {
-    await assertCompile("<name>", "Alice", { mode: "jse", target: shared });
-  });
-
-  test("object literal", async () => {
-    await assertCompile("{ message = greet(name) }", {
+  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), {
       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 () => {
@@ -75,8 +44,8 @@ describe("compile", () => {
   });
 
   test("async object", async () => {
-    const fn = compile.expression("{ a: { b = name }}", { globals: shared });
-    const object = await fn.call(null);
+    const fn = compile.expression("{ a: { b = name }}");
+    const object = await fn.call(shared);
     assert.deepEqual(await object.a.b, "Alice");
   });
 
@@ -99,7 +68,7 @@ describe("compile", () => {
 
   test("tagged template string array is identical across calls", async () => {
     let saved;
-    const globals = new ObjectTree({
+    const scope = new ObjectTree({
       tag: (strings, ...values) => {
         assertCodeEqual(strings, ["Hello, ", "!"]);
         if (saved) {
@@ -110,23 +79,29 @@ describe("compile", () => {
         return strings[0] + values[0] + strings[1];
       },
     });
-    const program = compile.expression("=tag`Hello, ${_}!`", { globals });
-    const lambda = await program.call(null);
+    const program = compile.expression("=tag`Hello, ${_}!`");
+    const lambda = await program.call(scope);
     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, 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);
-  }
+async function assertCompile(text, expected) {
+  const fn = compile.expression(text);
+  const result = await fn.call(shared);
   assert.deepEqual(result, expected);
 }

package/test/compiler/optimize.test.js

@@ -1,111 +1,42 @@
-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("change local references to context references", async () => {
-    const expression = `(name) => {
-      a: name,
-      b: a
-    }`;
-    const expected = [
+  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, [
       ops.lambda,
       [[ops.literal, "name"]],
       [
         ops.object,
-        ["a", [[ops.context, 1], "name"]],
-        ["b", [[ops.context], "a"]],
+        ["a", 1],
+        ["b", [ops.scope, "a"]],
+        ["c", [ops.external, "elsewhere", [ops.scope, "elsewhere"], {}]],
+        ["d", [ops.scope, "name"]],
       ],
-    ];
-    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("cache jse deeper scope references", async () => {
-    // Compilation of `{ property: <x> }`
+  test("optimize scope traversals with all literal keys", async () => {
+    // Compilation of `x/y.js`
     const code = createCode([
-      ops.object,
-      ["property", [[ops.scope], [ops.literal, "x"]]],
+      ops.traverse,
+      [ops.scope, "x/"],
+      [ops.literal, "y.js"],
     ]);
-    const expected = [
-      ops.object,
-      ["property", [ops.cache, {}, "x", [[ops.scope, [ops.context, 1]], "x"]]],
-    ];
-    assertCodeEqual(optimize(code, { mode: "jse" }), expected);
+    const optimized = optimize(code);
+    assertCodeEqual(optimized, [ops.external, "x/y.js", code, {}]);
   });
 });
-
-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);
-}