@weborigami/language 0.1.0 → 0.2.1

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,124 @@ 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} left
+ */
+export function makeBinaryOperation(left, [operatorToken, right]) {
+  const operators = {
+    "!=": ops.notEqual,
+    "!==": ops.notStrictEqual,
+    "%": ops.remainder,
+    "&": ops.bitwiseAnd,
+    "*": ops.multiplication,
+    "**": ops.exponentiation,
+    "+": ops.addition,
+    "-": ops.subtraction,
+    "/": ops.division,
+    "<": ops.lessThan,
+    "<<": ops.shiftLeft,
+    "<=": ops.lessThanOrEqual,
+    "==": ops.equal,
+    "===": ops.strictEqual,
+    ">": ops.greaterThan,
+    ">=": ops.greaterThanOrEqual,
+    ">>": ops.shiftRightSigned,
+    ">>>": ops.shiftRightUnsigned,
+    "^": ops.bitwiseXor,
+    "|": ops.bitwiseOr,
+  };
+  const op = operators[operatorToken];
+
+  /** @type {Code} */
+  // @ts-ignore
+  const 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 +293,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 +310,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 +334,30 @@ export function makeTemplate(op, head, tail) {
   }
   return [op, [ops.literal, strings], ...values];
 }
+
+export function makeUnaryOperation(operator, value) {
+  const operators = {
+    "!": ops.logicalNot,
+    "+": ops.unaryPlus,
+    "-": ops.unaryMinus,
+    "~": ops.bitwiseNot,
+  };
+  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;
+  }
+}