@weborigami/language 0.1.0 → 0.2.0

package/src/compiler/parserHelpers.js

@@ -4,16 +4,26 @@ import * as ops from "../runtime/ops.js";
 
 // Parser helpers
 
+/** @typedef {import("../../index.ts").Code} Code */
+
+// Marker for a reference that may be a builtin or a scope reference
+export const undetermined = Symbol("undetermined");
+
+const builtinRegex = /^[A-Za-z][A-Za-z0-9]*$/;
+
 /**
  * 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.
+ *
+ * @param {Code} code
+ * @param {any} location
  */
-export function annotate(parseResult, location) {
-  if (typeof parseResult === "object" && parseResult !== null && location) {
-    parseResult.location = location;
-    parseResult.source = codeFragment(location);
+export function annotate(code, location) {
+  if (typeof code === "object" && code !== null && location) {
+    code.location = location;
+    code.source = codeFragment(location);
   }
-  return parseResult;
+  return code;
 }
 
 /**
@@ -21,31 +31,51 @@ export function annotate(parseResult, location) {
  * Rewrite any [ops.scope, key] calls to be [ops.inherited, key] to avoid
  * infinite recursion.
  *
- * @param {import("../../index.ts").Code} code
+ * @param {Code} code
  * @param {string} key
  */
 function avoidRecursivePropertyCalls(code, key) {
   if (!(code instanceof Array)) {
     return code;
   }
+  /** @type {Code} */
   let modified;
   if (
     code[0] === ops.scope &&
     trailingSlash.remove(code[1]) === trailingSlash.remove(key)
   ) {
     // Rewrite to avoid recursion
+    // @ts-ignore
     modified = [ops.inherited, code[1]];
   } else if (code[0] === ops.lambda && code[1].includes(key)) {
     // Lambda that defines the key; don't rewrite
     return code;
   } else {
     // Process any nested code
+    // @ts-ignore
     modified = code.map((value) => avoidRecursivePropertyCalls(value, key));
   }
   annotate(modified, code.location);
   return modified;
 }
 
+/**
+ * Downgrade a potential builtin reference to a scope reference.
+ *
+ * @param {Code} code
+ */
+export function downgradeReference(code) {
+  if (code && code.length === 2 && code[0] === undetermined) {
+    /** @type {Code} */
+    // @ts-ignore
+    const result = [ops.scope, code[1]];
+    annotate(result, code.location);
+    return result;
+  } else {
+    return code;
+  }
+}
+
 // Return true if the code will generate an async object.
 function isCodeForAsyncObject(code) {
   if (!(code instanceof Array)) {
@@ -95,56 +125,111 @@ export function makeArray(entries) {
 }
 
 /**
- * @typedef {import("../../index.ts").Code} Code
+ * Create a chain of binary operators. The head is the first value, and the tail
+ * is an array of [operator, value] pairs.
  *
+ * @param {Code} head
+ * @param {[any, Code][]} tail
+ */
+export function makeBinaryOperatorChain(head, tail) {
+  /** @type {Code} */
+  let value = head;
+  for (const [operatorToken, right] of tail) {
+    const left = value;
+    const operators = {
+      "===": ops.strictEqual,
+      "!==": ops.notStrictEqual,
+      "==": ops.equal,
+      "!=": ops.notEqual,
+    };
+    const op = operators[operatorToken];
+    // @ts-ignore
+    value = [op, left, right];
+    value.location = {
+      source: left.location.source,
+      start: left.location.start,
+      end: right.location.end,
+    };
+  }
+  return value;
+}
+
+/**
  * @param {Code} target
- * @param {Code[]} chain
- * @returns
+ * @param {any[]} args
  */
-export function makeFunctionCall(target, chain, location) {
+export function makeCall(target, args) {
   if (!(target instanceof Array)) {
     const error = new SyntaxError(`Can't call this like a function: ${target}`);
-    /** @type {any} */ (error).location = location;
+    /** @type {any} */ (error).location = /** @type {any} */ (target).location;
     throw error;
   }
 
-  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) {
-    /** @type {Code} */
-    let fnCall;
 
-    // @ts-ignore
-    fnCall =
-      args[0] !== ops.traverse
-        ? // Function call
-          [value, ...args]
-        : args.length > 1
-        ? // Traverse
-          [ops.traverse, value, ...args.slice(1)]
-        : // Traverse without arguments equates to unpack
-          [ops.unpack, value];
-
-    // 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";
+  let fnCall;
+  if (args[0] === ops.traverse) {
+    let tree = target;
+
+    if (tree[0] === undetermined) {
+      // In a traversal, downgrade ops.builtin references to ops.scope
+      tree = downgradeReference(tree);
+      if (tree[0] === ops.scope && !trailingSlash.has(tree[1])) {
+        // Target didn't parse with a trailing slash; add one
+        tree[1] = trailingSlash.add(tree[1]);
       }
     }
 
-    annotate(fnCall, { start, source, end });
+    if (args.length > 1) {
+      // Regular traverse
+      const keys = args.slice(1);
+      fnCall = [ops.traverse, tree, ...keys];
+    } else {
+      // Traverse without arguments equates to unpack
+      fnCall = [ops.unpack, tree];
+    }
+  } else if (args[0] === ops.template) {
+    // Tagged template
+    fnCall = [upgradeReference(target), ...args.slice(1)];
+  } else {
+    // Function call with explicit or implicit parentheses
+    fnCall = [upgradeReference(target), ...args];
+  }
 
-    value = fnCall;
+  // Create a location spanning the newly-constructed function call.
+  if (args instanceof Array) {
+    // @ts-ignore
+    end = args.location?.end ?? args.at(-1)?.location?.end;
+    if (end === undefined) {
+      throw "Internal parser error: no location for function call argument";
+    }
   }
 
-  return value;
+  // @ts-ignore
+  annotate(fnCall, { start, source, end });
+
+  return fnCall;
+}
+
+/**
+ * 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
+ * literal, we leave it alone.
+ *
+ * @param {any[]} args
+ */
+export function makeDeferredArguments(args) {
+  return args.map((arg) => {
+    if (arg instanceof Array && arg[0] === ops.literal) {
+      return arg;
+    }
+    const fn = [ops.lambda, [], arg];
+    // @ts-ignore
+    annotate(fn, arg.location);
+    return fn;
+  });
 }
 
 export function makeObject(entries, op) {
@@ -195,13 +280,15 @@ export function makeObject(entries, op) {
 }
 
 // Similar to a function call, but the order is reversed.
-export function makePipeline(steps) {
-  const [first, ...rest] = steps;
-  let value = first;
-  for (const args of rest) {
-    value = [args, value];
-  }
-  return value;
+export function makePipeline(arg, fn) {
+  const upgraded = upgradeReference(fn);
+  const result = makeCall(upgraded, [arg]);
+  const source = fn.location.source;
+  let start = arg.location.start;
+  let end = fn.location.end;
+  // @ts-ignore
+  annotate(result, { start, source, end });
+  return result;
 }
 
 // Define a property on an object.
@@ -210,6 +297,21 @@ export function makeProperty(key, value) {
   return [key, modified];
 }
 
+export function makeReference(identifier) {
+  // We can't know for sure that an identifier is a builtin reference until we
+  // see whether it's being called as a function.
+  let op;
+  if (builtinRegex.test(identifier)) {
+    op = identifier.endsWith(":")
+      ? // Namespace is always a builtin reference
+        ops.builtin
+      : undetermined;
+  } else {
+    op = ops.scope;
+  }
+  return [op, identifier];
+}
+
 export function makeTemplate(op, head, tail) {
   const strings = [head];
   const values = [];
@@ -219,3 +321,27 @@ export function makeTemplate(op, head, tail) {
   }
   return [op, [ops.literal, strings], ...values];
 }
+
+export function makeUnaryOperatorCall(operator, value) {
+  const operators = {
+    "!": ops.logicalNot,
+  };
+  return [operators[operator], value];
+}
+
+/**
+ * Upgrade a potential builtin reference to an actual builtin reference.
+ *
+ * @param {Code} code
+ */
+export function upgradeReference(code) {
+  if (code.length === 2 && code[0] === undetermined) {
+    /** @type {Code} */
+    // @ts-ignore
+    const result = [ops.builtin, code[1]];
+    annotate(result, code.location);
+    return result;
+  } else {
+    return code;
+  }
+}

package/src/runtime/ops.js

@@ -48,26 +48,42 @@ export async function builtin(key) {
   if (!this) {
     throw new Error("Tried to get the scope of a null or undefined tree.");
   }
-  let current = this;
-  while (current.parent) {
-    current = current.parent;
-  }
 
-  const value = await current.get(key);
+  const builtins = Tree.root(this);
+  const value = await builtins.get(key);
   if (value === undefined) {
-    throw await builtinReferenceError(this, current, key);
+    throw await builtinReferenceError(this, builtins, key);
   }
 
   return value;
 }
 
 /**
- * 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.
+ * Concatenate the given arguments.
+ *
+ * @this {AsyncTree|null}
+ * @param {any[]} args
+ */
+export async function concat(...args) {
+  return treeConcat.call(this, args);
+}
+addOpLabel(concat, "«ops.concat»");
+
+export async function conditional(condition, truthy, falsy) {
+  return condition ? truthy() : falsy();
+}
+
+export async function equal(a, b) {
+  return a == b;
+}
+
+/**
+ * Look up the given key as an external reference and cache the value for future
+ * requests.
  *
  * @this {AsyncTree|null}
  */
-export async function cache(key, cache) {
+export async function external(key, cache) {
   if (key in cache) {
     return cache[key];
   }
@@ -80,42 +96,20 @@ export async function cache(key, cache) {
   return value;
 }
 
-/**
- * Concatenate the given arguments.
- *
- * @this {AsyncTree|null}
- * @param {any[]} args
- */
-export async function concat(...args) {
-  return treeConcat.call(this, args);
-}
-addOpLabel(concat, "«ops.concat»");
-
 /**
  * This op is only used during parsing. It signals to ops.object that the
  * "arguments" of the expression should be used to define a property getter.
  */
 export const getter = new String("«ops.getter»");
 
-/**
- * Files tree for the filesystem root.
- *
- * @this {AsyncTree|null}
- */
-export async function filesRoot() {
-  let tree = new OrigamiFiles("/");
-  tree.parent = root(this);
-  return tree;
-}
-
 /**
  * Files tree for the user's home directory.
  *
  * @this {AsyncTree|null}
  */
-export async function homeTree() {
+export async function homeDirectory() {
   const tree = new OrigamiFiles(os.homedir());
-  tree.parent = root(this);
+  tree.parent = this ? Tree.root(this) : null;
   return tree;
 }
 
@@ -143,31 +137,37 @@ addOpLabel(inherited, "«ops.inherited»");
  * @param {string[]} parameters
  * @param {Code} code
  */
-
 export function lambda(parameters, code) {
   const context = this;
 
   /** @this {Treelike|null} */
   async function invoke(...args) {
-    // Add arguments to scope.
-    const ambients = {};
-    for (const parameter of parameters) {
-      ambients[parameter] = args.shift();
+    let target;
+    if (parameters.length === 0) {
+      // No parameters
+      target = context;
+    } else {
+      // Add arguments to scope.
+      const ambients = {};
+      for (const parameter of parameters) {
+        ambients[parameter] = args.shift();
+      }
+      Object.defineProperty(ambients, codeSymbol, {
+        value: code,
+        enumerable: false,
+      });
+      const ambientTree = new ObjectTree(ambients);
+      ambientTree.parent = context;
+      target = ambientTree;
     }
-    Object.defineProperty(ambients, codeSymbol, {
-      value: code,
-      enumerable: false,
-    });
-    const ambientTree = new ObjectTree(ambients);
-    ambientTree.parent = context;
 
-    let result = await evaluate.call(ambientTree, code);
+    let result = await evaluate.call(target, code);
 
     // Bind a function result to the ambients so that it has access to the
     // parameter values -- i.e., like a closure.
     if (result instanceof Function) {
       const resultCode = result.code;
-      result = result.bind(ambientTree);
+      result = result.bind(target);
       if (code) {
         // Copy over Origami code
         result.code = resultCode;
@@ -198,6 +198,53 @@ export async function literal(value) {
 }
 addOpLabel(literal, "«ops.literal»");
 
+/**
+ * Logical AND operator
+ */
+export async function logicalAnd(head, ...tail) {
+  if (!head) {
+    return head;
+  }
+  // Evaluate the tail arguments in order, short-circuiting if any are falsy.
+  let lastValue;
+  for (const arg of tail) {
+    lastValue = arg instanceof Function ? await arg() : arg;
+    if (!lastValue) {
+      return lastValue;
+    }
+  }
+
+  // Return the last value (not `true`)
+  return lastValue;
+}
+
+/**
+ * Logical NOT operator
+ */
+export async function logicalNot(value) {
+  return !value;
+}
+
+/**
+ * Logical OR operator
+ */
+export async function logicalOr(head, ...tail) {
+  if (head) {
+    return head;
+  }
+
+  // Evaluate the tail arguments in order, short-circuiting if any are truthy.
+  let lastValue;
+  for (const arg of tail) {
+    lastValue = arg instanceof Function ? await arg() : arg;
+    if (lastValue) {
+      return lastValue;
+    }
+  }
+
+  return lastValue;
+}
+
 /**
  * Merge the given trees. If they are all plain objects, return a plain object.
  *
@@ -222,14 +269,45 @@ export async function object(...entries) {
 }
 addOpLabel(object, "«ops.object»");
 
-// Return the root of the given tree. For an Origami tree, this gives us
-// a way of acessing the builtins.
-function root(tree) {
-  let current = tree;
-  while (current.parent) {
-    current = current.parent;
+export async function notEqual(a, b) {
+  return a != b;
+}
+
+export async function notStrictEqual(a, b) {
+  return a !== b;
+}
+
+/**
+ * Nullish coalescing operator
+ */
+export async function nullishCoalescing(head, ...tail) {
+  if (head != null) {
+    return head;
+  }
+
+  let lastValue;
+  for (const arg of tail) {
+    lastValue = arg instanceof Function ? await arg() : arg;
+    if (lastValue != null) {
+      return lastValue;
+    }
   }
-  return current;
+
+  return lastValue;
+}
+
+/**
+ * Files tree for the filesystem root.
+ *
+ * @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;
 }
 
 /**
@@ -243,7 +321,7 @@ export async function scope(key) {
   }
   const scope = scopeFn(this);
   const value = await scope.get(key);
-  if (value === undefined) {
+  if (value === undefined && key !== "undefined") {
     throw await scopeReferenceError(scope, key);
   }
   return value;
@@ -256,11 +334,15 @@ addOpLabel(scope, "«ops.scope»");
  */
 export function spread(...args) {
   throw new Error(
-    "A compile-time spread operator wasn't converted to an object merge."
+    "Internal error: a spread operation wasn't compiled correctly."
   );
 }
 addOpLabel(spread, "«ops.spread»");
 
+export async function strictEqual(a, b) {
+  return a === b;
+}
+
 /**
  * Apply the default tagged template function.
  */

package/test/cases/ReadMe.md

@@ -0,0 +1 @@
+This folder defines expression tests in YAML files so that we can programmatically test the evaluation of the expressions in both JavaScript and Origami.

package/test/cases/conditionalExpression.yaml

@@ -0,0 +1,101 @@
+# Conditional (ternary) expression tests
+
+- source: "true ? 42 : 0"
+  expected: 42
+  description: "Condition is true, evaluates and returns the first operand"
+
+- source: "false ? 42 : 0"
+  expected: 0
+  description: "Condition is false, evaluates and returns the second operand"
+
+- source: "1 ? 'yes' : 'no'"
+  expected: "yes"
+  description: "Truthy condition with string operands"
+
+- source: "0 ? 'yes' : 'no'"
+  expected: "no"
+  description: "Falsy condition with string operands"
+
+- source: "'non-empty' ? 1 : 2"
+  expected: 1
+  description: "Truthy string condition with numeric operands"
+
+- source: "'' ? 1 : 2"
+  expected: 2
+  description: "Falsy string condition with numeric operands"
+
+- source: "null ? 'a' : 'b'"
+  expected: "b"
+  description: "Falsy null condition"
+
+- source: "undefined ? 'a' : 'b'"
+  expected: "b"
+  description: "Falsy undefined condition"
+
+- source: "NaN ? 'a' : 'b'"
+  expected: "b"
+  description: "Falsy NaN condition"
+
+- source: "42 ? true : false"
+  expected: true
+  description: "Truthy numeric condition with boolean operands"
+
+- source: "0 ? true : false"
+  expected: false
+  description: "Falsy numeric condition with boolean operands"
+
+- source: "[] ? 'array' : 'no array'"
+  expected: "array"
+  description: "Truthy array condition"
+
+- source: "{} ? 'object' : 'no object'"
+  expected: "object"
+  description: "Truthy object condition"
+
+- source: "false ? null : undefined"
+  expected: __undefined__
+  description: "Condition is false, returns undefined"
+
+- source: "null ? null : null"
+  expected: __null__
+  description: "Condition is falsy, returns null"
+
+- source: "true ? NaN : 42"
+  expected: __NaN__
+  description: "Condition is true, evaluates and returns NaN"
+
+- source: "(true ? 1 : 2) ? 3 : 4"
+  expected: 3
+  description: "Nested ternary where first expression evaluates to 1, which is truthy"
+
+- source: "(false ? 1 : 2) ? 3 : 4"
+  expected: 3
+  description: "Nested ternary where first expression evaluates to 2, which is truthy"
+
+- source: "(false ? 1 : 0) ? 3 : 4"
+  expected: 4
+  description: "Nested ternary where first expression evaluates to 0, which is falsy"
+
+- source: "true ? (false ? 10 : 20) : 30"
+  expected: 20
+  description: "Nested ternary in the true branch of outer ternary"
+
+- source: "false ? (false ? 10 : 20) : 30"
+  expected: 30
+  description: "Nested ternary in the false branch of outer ternary"
+
+# - source: "'truthy' ? 1 + 2 : 3 + 4"
+#   expected: 3
+#   description: "Evaluates and returns the true branch with an arithmetic expression"
+
+# - source: "'' ? 1 + 2 : 3 + 4"
+#   expected: 7
+#   description: "Evaluates and returns the false branch with an arithmetic expression"
+
+- source: "undefined ? undefined : null"
+  expected: __null__
+  description: "Condition is falsy, returns null"
+
+- source: "null ? undefined : undefined"
+  expected: __undefined__
+  description: "Condition is falsy, returns undefined"