@weborigami/language 0.6.2 → 0.6.4

package/src/compiler/parserHelpers.js

@@ -20,6 +20,7 @@ export const markers = {
   external: Symbol("external"), // External reference
   property: Symbol("property"), // Property access
   reference: Symbol("reference"), // Reference to local, scope, or global
+  spread: Symbol("spread"), // Spread operator
   traverse: Symbol("traverse"), // Path traversal
 };
 
@@ -79,7 +80,7 @@ export function makeArray(entries, location) {
   const spreads = [];
 
   for (const value of entries) {
-    if (Array.isArray(value) && value[0] === ops.spread) {
+    if (Array.isArray(value) && value[0] === markers.spread) {
       if (currentEntries.length > 0) {
         const location = { ...currentEntries[0].location };
         location.end = currentEntries[currentEntries.length - 1].location.end;
@@ -95,22 +96,20 @@ export function makeArray(entries, location) {
     }
   }
 
-  // Finish any current entries.
+  if (spreads.length === 0) {
+    // No spreads, simple array
+    return annotate([ops.array, ...currentEntries], location);
+  }
+
+  // Finish any current entries, add to spreads
   if (currentEntries.length > 0) {
     spreads.push([ops.array, ...currentEntries]);
     currentEntries = [];
   }
 
-  let result;
-  if (spreads.length > 1) {
-    result = [ops.flat, ...spreads];
-  } else if (spreads.length === 1) {
-    result = spreads[0];
-  } else {
-    result = [ops.array];
-  }
-
-  return annotate(result, location);
+  // We don't optimize for the single-spread case here because the object
+  // being spread might be a tree and we want ops.flat to handle that.
+  return annotate([ops.flat, ...spreads], location);
 }
 
 /**
@@ -171,27 +170,60 @@ export function makeCall(target, args, location) {
 
   let fnCall;
   const op = args[0];
-  if (op === markers.traverse /* || op === ops.optionalTraverse */) {
-    // Traverse
-    const keys = args.slice(1);
-    fnCall = [target, ...keys];
-  } else if (op === markers.property) {
-    // Property access
-    const property = args[1];
-    fnCall = [ops.property, target, property];
-  } else if (op === ops.templateText) {
-    // Tagged template
-    const strings = args[1];
-    const values = args.slice(2);
-    fnCall = makeTaggedTemplateCall(target, strings, ...values);
-  } else {
-    // Function call with explicit or implicit parentheses
-    fnCall = [target, ...args];
+  switch (op) {
+    case markers.property:
+      // Property access
+      const property = args[1];
+      fnCall = [ops.property, target, property];
+      break;
+
+    case ops.templateText:
+      // Tagged template
+      const strings = args[1];
+      const values = args.slice(2);
+      fnCall = makeTaggedTemplateCall(target, strings, ...values);
+      break;
+
+    case markers.traverse:
+      // Traverse
+      const keys = args.slice(1);
+      fnCall = [target, ...keys];
+      break;
+
+    default:
+      // Function call with explicit or implicit parentheses
+      fnCall = makePossibleSpreadCall(target, args, location);
+      break;
   }
 
   return annotate(fnCall, location);
 }
 
+/**
+ * Create a chain of function calls, property accesses, or traversals.
+ *
+ * @param {AnnotatedCode} target
+ * @param {AnnotatedCode[]} chain
+ * @param {CodeLocation} location
+ */
+export function makeCallChain(target, chain, location) {
+  let result = target;
+  let args = chain.shift();
+  while (args) {
+    const op = args[0];
+    if (op === ops.optional) {
+      // Optional chaining short-circuits the rest of the call chain
+      const optionalChain = [args[1], ...chain];
+      return makeOptionalCall(result, optionalChain, location);
+    } else {
+      // Extend normal call chain
+      result = makeCall(result, args, location);
+    }
+    args = chain.shift();
+  }
+  return result;
+}
+
 /**
  * For functions that short-circuit arguments, we need to defer evaluation of
  * the arguments until the function is called. Exception: if the argument is a
@@ -301,7 +333,7 @@ export function makeObject(entries, location) {
 
   for (let entry of entries) {
     const [key, value] = entry;
-    if (key === ops.spread) {
+    if (key === markers.spread) {
       if (value[0] === ops.object) {
         // Spread of an object; fold into current object
         currentEntries.push(...value.slice(1));
@@ -361,6 +393,39 @@ export function makeObject(entries, location) {
   return annotate(code, location);
 }
 
+/**
+ * Make an optional call: if the target is null or undefined, return undefined;
+ * otherwise, make the call.
+ *
+ * @param {AnnotatedCode} target
+ * @param {AnnotatedCode[]} chain
+ * @param {CodeLocation} location
+ */
+function makeOptionalCall(target, chain, location) {
+  const optionalKey = "__optional__";
+  // Create a reference to the __optional__ parameter
+  const optionalReference = annotate(
+    [markers.reference, optionalKey],
+    location
+  );
+  const optionalTraverse = annotate(
+    [markers.traverse, optionalReference],
+    location
+  );
+
+  // Create the call to be made if the target is not null/undefined
+  const call = makeCallChain(optionalTraverse, chain, location);
+
+  // Create a function that takes __optional__ and makes the call
+  const optionalLiteral = annotate([ops.literal, optionalKey], location);
+  const lambdaParameters = annotate([optionalLiteral], location);
+  const lambda = annotate([ops.lambda, lambdaParameters, call], location);
+
+  // Create the call to ops.optional
+  const optionalCall = annotate([ops.optional, target, lambda], location);
+  return optionalCall;
+}
+
 /**
  * Handle a path with one or more segments separated by slashes.
  *
@@ -398,6 +463,28 @@ export function makePipeline(arg, fn, location) {
   return annotate(result, { start, source, end });
 }
 
+function makePossibleSpreadCall(target, args, location) {
+  const hasSpread = args.some(
+    (arg) => Array.isArray(arg) && arg[0] === markers.spread
+  );
+  if (!hasSpread) {
+    // No spreads, simple call
+    return [target, ...args];
+  }
+
+  // Get function's apply method
+  const applyMethod = annotate([ops.property, target, "apply"], location);
+  const wrappedArgs = args.map((arg) => {
+    if (arg[0] === markers.spread) {
+      return arg[1];
+    } else {
+      return annotate([ops.array, arg], arg.location);
+    }
+  });
+  const flatCall = annotate([ops.flat, ...wrappedArgs], location);
+  return [applyMethod, null, flatCall];
+}
+
 /**
  * Make a tagged template call
  *

package/src/project/jsGlobals.js

@@ -173,7 +173,7 @@ async function fetchWrapper(resource, options) {
  *
  * @this {AsyncMap|null|undefined}
  */
-async function importWrapper(modulePath) {
+async function importWrapper(modulePath, options = {}) {
   // Walk up parent tree looking for a FileTree or other object with a `path`
   /** @type {any} */
   let current = this;
@@ -186,7 +186,7 @@ async function importWrapper(modulePath) {
     );
   }
   const filePath = path.resolve(current.path, modulePath);
-  return import(filePath);
+  return import(filePath, options);
 }
 importWrapper.containerAsTarget = true;
 

package/src/runtime/expressionObject.js

@@ -35,11 +35,21 @@ export default async function expressionObject(entries, state = {}) {
   }
   setParent(object, parent);
 
+  // Get the keys, which might included computed keys
+  const computedKeys = await Promise.all(
+    entries.map(async ([key]) =>
+      key instanceof Array ? await evaluate(key, state) : key
+    )
+  );
+
   let tree;
   const eagerProperties = [];
   const propertyIsEnumerable = {};
   let hasLazyProperties = false;
-  for (let [key, value] of entries) {
+  for (let i = 0; i < entries.length; i++) {
+    let key = computedKeys[i];
+    let value = entries[i][1];
+
     // Determine if we need to define a getter or a regular property. If the key
     // has an extension, we need to define a getter. If the value is code (an
     // array), we need to define a getter -- but if that code takes the form
@@ -107,7 +117,14 @@ export default async function expressionObject(entries, state = {}) {
   Object.defineProperty(object, symbols.keys, {
     configurable: true,
     enumerable: false,
-    value: () => keys(object, eagerProperties, propertyIsEnumerable, entries),
+    value: () =>
+      objectKeys(
+        object,
+        computedKeys,
+        eagerProperties,
+        propertyIsEnumerable,
+        entries
+      ),
     writable: true,
   });
 
@@ -140,6 +157,11 @@ export default async function expressionObject(entries, state = {}) {
 export function entryKey(entry, object = null, eagerProperties = []) {
   let [key, value] = entry;
 
+  if (typeof key !== "string") {
+    // Computed property key
+    return null;
+  }
+
   if (key[0] === "(" && key[key.length - 1] === ")") {
     // Non-enumerable property, remove parentheses. This doesn't come up in the
     // constructor, but can happen in situations encountered by the compiler's
@@ -182,8 +204,22 @@ export function entryKey(entry, object = null, eagerProperties = []) {
   return key;
 }
 
-function keys(object, eagerProperties, propertyIsEnumerable, entries) {
-  return entries
-    .filter(([key]) => propertyIsEnumerable[key])
-    .map((entry) => entryKey(entry, object, eagerProperties));
+function objectKeys(
+  object,
+  computedKeys,
+  eagerProperties,
+  propertyIsEnumerable,
+  entries
+) {
+  // If the key is a simple string key and it's enumerable, get the friendly
+  // version of it; if it's a computed key used that.
+  const keys = entries.map((entry, index) =>
+    typeof entry[0] !== "string"
+      ? computedKeys[index]
+      : propertyIsEnumerable[entry[0]]
+      ? entryKey(entry, object, eagerProperties)
+      : null
+  );
+  // Return the enumerable keys
+  return keys.filter((key) => key !== null);
 }

package/src/runtime/ops.js

@@ -416,13 +416,20 @@ export async function params(depth, state = {}) {
 addOpLabel(params, "«ops.params»");
 params.needsState = true;
 
-// export function optionalTraverse(maplike, key) {
-//   if (!maplike) {
-//     return undefined;
-//   }
-//   return Tree.traverseOrThrow(maplike, key);
-// }
-// addOpLabel(optionalTraverse, "«ops.optionalTraverse");
+/**
+ * If the value is null or undefined, return undefined; otherwise, invoke the
+ * given function with the value.
+ *
+ * @param {any} value
+ * @param {Function} fn
+ */
+export function optional(value, fn) {
+  if (value == null) {
+    return undefined;
+  }
+  return fn(value);
+}
+addOpLabel(optional, "«ops.optional»");
 
 /**
  * Return the indicated property
@@ -505,17 +512,6 @@ export function shiftRightUnsigned(a, b) {
 }
 addOpLabel(shiftRightUnsigned, "«ops.shiftRightUnsigned»");
 
-/**
- * The spread operator is a placeholder during parsing. It should be replaced
- * with an object merge.
- */
-export function spread(arg) {
-  throw new Error(
-    "Internal error: a spread operation wasn't compiled correctly."
-  );
-}
-addOpLabel(spread, "«ops.spread»");
-
 export function strictEqual(a, b) {
   return a === b;
 }

package/test/compiler/compile.test.js

@@ -5,6 +5,7 @@ import * as compile from "../../src/compiler/compile.js";
 import { assertCodeEqual } from "./codeHelpers.js";
 
 const globals = {
+  concat: (...args) => args.join(""),
   greet: (name) => `Hello, ${name}!`,
   name: "Alice",
 };
@@ -22,6 +23,13 @@ describe("compile", () => {
     await assertCompile("greet 'world'", "Hello, world!", { mode: "shell" });
   });
 
+  test("function call with spread", async () => {
+    await assertCompile(
+      `concat("Hello", ...[", ", name], "!")`,
+      "Hello, Alice!"
+    );
+  });
+
   test("angle bracket path", async () => {
     await assertCompile("<data>", "Bob", {
       target: {
@@ -43,6 +51,12 @@ describe("compile", () => {
     );
   });
 
+  test("object with computed property key", async () => {
+    await assertCompile("{ [name] = greet(name) }", {
+      Alice: "Hello, Alice!",
+    });
+  });
+
   test("merge", async () => {
     {
       const globals = {