@weborigami/language 0.2.0 → 0.2.1

package/src/compiler/parserHelpers.js

@@ -128,29 +128,42 @@ export function makeArray(entries) {
  * 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
+ * @param {Code} left
  */
-export function makeBinaryOperatorChain(head, tail) {
+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} */
-  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,
-    };
-  }
+  // @ts-ignore
+  const value = [op, left, right];
+  value.location = {
+    source: left.location.source,
+    start: left.location.start,
+    end: right.location.end,
+  };
+
   return value;
 }
 
@@ -322,9 +335,12 @@ export function makeTemplate(op, head, tail) {
   return [op, [ops.literal, strings], ...values];
 }
 
-export function makeUnaryOperatorCall(operator, value) {
+export function makeUnaryOperation(operator, value) {
   const operators = {
     "!": ops.logicalNot,
+    "+": ops.unaryPlus,
+    "-": ops.unaryMinus,
+    "~": ops.bitwiseNot,
   };
   return [operators[operator], value];
 }

package/src/runtime/ops.js

@@ -27,6 +27,31 @@ function addOpLabel(op, label) {
   });
 }
 
+export function addition(a, b) {
+  return a + b;
+}
+addOpLabel(addition, "«ops.addition»");
+
+export function bitwiseAnd(a, b) {
+  return a & b;
+}
+addOpLabel(bitwiseAnd, "«ops.bitwiseAnd»");
+
+export function bitwiseNot(a) {
+  return ~a;
+}
+addOpLabel(bitwiseNot, "«ops.bitwiseNot»");
+
+export function bitwiseOr(a, b) {
+  return a | b;
+}
+addOpLabel(bitwiseOr, "«ops.bitwiseOr»");
+
+export function bitwiseXor(a, b) {
+  return a ^ b;
+}
+addOpLabel(bitwiseXor, "«ops.bitwiseXor»");
+
 /**
  * Construct an array.
  *
@@ -58,6 +83,17 @@ export async function builtin(key) {
   return value;
 }
 
+/**
+ * JavaScript comma operator, returns the last argument.
+ *
+ * @param  {...any} args
+ * @returns
+ */
+export function comma(...args) {
+  return args.at(-1);
+}
+addOpLabel(comma, "«ops.comma»");
+
 /**
  * Concatenate the given arguments.
  *
@@ -73,9 +109,20 @@ export async function conditional(condition, truthy, falsy) {
   return condition ? truthy() : falsy();
 }
 
-export async function equal(a, b) {
+export function division(a, b) {
+  return a / b;
+}
+addOpLabel(division, "«ops.division»");
+
+export function equal(a, b) {
   return a == b;
 }
+addOpLabel(equal, "«ops.equal»");
+
+export function exponentiation(a, b) {
+  return a ** b;
+}
+addOpLabel(exponentiation, "«ops.exponentiation»");
 
 /**
  * Look up the given key as an external reference and cache the value for future
@@ -102,6 +149,16 @@ export async function external(key, cache) {
  */
 export const getter = new String("«ops.getter»");
 
+export function greaterThan(a, b) {
+  return a > b;
+}
+addOpLabel(greaterThan, "«ops.greaterThan»");
+
+export function greaterThanOrEqual(a, b) {
+  return a >= b;
+}
+addOpLabel(greaterThanOrEqual, "«ops.greaterThanOrEqual»");
+
 /**
  * Files tree for the user's home directory.
  *
@@ -190,6 +247,16 @@ export function lambda(parameters, code) {
 }
 addOpLabel(lambda, "«ops.lambda");
 
+export function lessThan(a, b) {
+  return a < b;
+}
+addOpLabel(lessThan, "«ops.lessThan»");
+
+export function lessThanOrEqual(a, b) {
+  return a <= b;
+}
+addOpLabel(lessThanOrEqual, "«ops.lessThanOrEqual»");
+
 /**
  * Return a primitive value
  */
@@ -256,26 +323,20 @@ export async function merge(...trees) {
 }
 addOpLabel(merge, "«ops.merge»");
 
-/**
- * Construct an object. The keys will be the same as the given `obj`
- * parameter's, and the values will be the results of evaluating the
- * corresponding code values in `obj`.
- *
- * @this {AsyncTree|null}
- * @param {any[]} entries
- */
-export async function object(...entries) {
-  return expressionObject(entries, this);
+export function multiplication(a, b) {
+  return a * b;
 }
-addOpLabel(object, "«ops.object»");
+addOpLabel(multiplication, "«ops.multiplication»");
 
-export async function notEqual(a, b) {
+export function notEqual(a, b) {
   return a != b;
 }
+addOpLabel(notEqual, "«ops.notEqual»");
 
-export async function notStrictEqual(a, b) {
+export function notStrictEqual(a, b) {
   return a !== b;
 }
+addOpLabel(notStrictEqual, "«ops.notStrictEqual»");
 
 /**
  * Nullish coalescing operator
@@ -296,6 +357,24 @@ export async function nullishCoalescing(head, ...tail) {
   return lastValue;
 }
 
+/**
+ * Construct an object. The keys will be the same as the given `obj`
+ * parameter's, and the values will be the results of evaluating the
+ * corresponding code values in `obj`.
+ *
+ * @this {AsyncTree|null}
+ * @param {any[]} entries
+ */
+export async function object(...entries) {
+  return expressionObject(entries, this);
+}
+addOpLabel(object, "«ops.object»");
+
+export function remainder(a, b) {
+  return a % b;
+}
+addOpLabel(remainder, "«ops.remainder»");
+
 /**
  * Files tree for the filesystem root.
  *
@@ -328,6 +407,21 @@ export async function scope(key) {
 }
 addOpLabel(scope, "«ops.scope»");
 
+export function shiftLeft(a, b) {
+  return a << b;
+}
+addOpLabel(shiftLeft, "«ops.shiftLeft»");
+
+export function shiftRightSigned(a, b) {
+  return a >> b;
+}
+addOpLabel(shiftRightSigned, "«ops.shiftRightSigned»");
+
+export function shiftRightUnsigned(a, b) {
+  return a >>> b;
+}
+addOpLabel(shiftRightUnsigned, "«ops.shiftRightUnsigned»");
+
 /**
  * The spread operator is a placeholder during parsing. It should be replaced
  * with an object merge.
@@ -339,9 +433,15 @@ export function spread(...args) {
 }
 addOpLabel(spread, "«ops.spread»");
 
-export async function strictEqual(a, b) {
+export function strictEqual(a, b) {
   return a === b;
 }
+addOpLabel(strictEqual, "«ops.strictEqual»");
+
+export function subtraction(a, b) {
+  return a - b;
+}
+addOpLabel(subtraction, "«ops.subtraction»");
 
 /**
  * Apply the default tagged template function.
@@ -356,6 +456,16 @@ addOpLabel(template, "«ops.template»");
  */
 export const traverse = Tree.traverseOrThrow;
 
+export function unaryMinus(a) {
+  return -a;
+}
+addOpLabel(unaryMinus, "«ops.unaryMinus»");
+
+export function unaryPlus(a) {
+  return +a;
+}
+addOpLabel(unaryPlus, "«ops.unaryPlus»");
+
 /**
  * If the value is packed but has an unpack method, call it and return that as
  * the result; otherwise, return the value as is.

package/test/compiler/parse.test.js

@@ -6,6 +6,19 @@ import * as ops from "../../src/runtime/ops.js";
 import { stripCodeLocations } from "./stripCodeLocations.js";
 
 describe("Origami parser", () => {
+  test("additiveExpression", () => {
+    assertParse("additiveExpression", "1 + 2", [
+      ops.addition,
+      [ops.literal, 1],
+      [ops.literal, 2],
+    ]);
+    assertParse("additiveExpression", "5 - 4", [
+      ops.subtraction,
+      [ops.literal, 5],
+      [ops.literal, 4],
+    ]);
+  });
+
   test("arrayLiteral", () => {
     assertParse("arrayLiteral", "[]", [ops.array]);
     assertParse("arrayLiteral", "[1, 2, 3]", [
@@ -20,6 +33,13 @@ describe("Origami parser", () => {
       [ops.literal, 2],
       [ops.literal, 3],
     ]);
+    assertParse("arrayLiteral", "[1,,,4]", [
+      ops.array,
+      [ops.literal, 1],
+      [ops.literal, undefined],
+      [ops.literal, undefined],
+      [ops.literal, 4],
+    ]);
     assertParse("arrayLiteral", "[ 1, ...[2, 3]]", [
       ops.merge,
       [ops.array, [ops.literal, 1]],
@@ -42,6 +62,11 @@ describe("Origami parser", () => {
       [],
       [ops.scope, "foo"],
     ]);
+    assertParse("arrowFunction", "x => y", [
+      ops.lambda,
+      ["x"],
+      [ops.scope, "y"],
+    ]);
     assertParse("arrowFunction", "(a, b, c) ⇒ fn(a, b, c)", [
       ops.lambda,
       ["a", "b", "c"],
@@ -52,7 +77,7 @@ describe("Origami parser", () => {
         [ops.scope, "c"],
       ],
     ]);
-    assertParse("arrowFunction", "(a) => (b) => fn(a, b)", [
+    assertParse("arrowFunction", "a => b => fn(a, b)", [
       ops.lambda,
       ["a"],
       [
@@ -67,6 +92,30 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("bitwiseAndExpression", () => {
+    assertParse("bitwiseAndExpression", "5 & 3", [
+      ops.bitwiseAnd,
+      [ops.literal, 5],
+      [ops.literal, 3],
+    ]);
+  });
+
+  test("bitwiseOrExpression", () => {
+    assertParse("bitwiseOrExpression", "5 | 3", [
+      ops.bitwiseOr,
+      [ops.literal, 5],
+      [ops.literal, 3],
+    ]);
+  });
+
+  test("bitwiseXorExpression", () => {
+    assertParse("bitwiseXorExpression", "5 ^ 3", [
+      ops.bitwiseXor,
+      [ops.literal, 5],
+      [ops.literal, 3],
+    ]);
+  });
+
   test("callExpression", () => {
     assertParse("callExpression", "fn()", [[ops.builtin, "fn"], undefined]);
     assertParse("callExpression", "foo.js(arg)", [
@@ -183,6 +232,16 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("commaExpression", () => {
+    assertParse("commaExpression", "1", [ops.literal, 1]);
+    assertParse("commaExpression", "a, b, c", [
+      ops.comma,
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+      [ops.scope, "c"],
+    ]);
+  });
+
   test("conditionalExpression", () => {
     assertParse("conditionalExpression", "1", [ops.literal, 1]);
     assertParse("conditionalExpression", "true ? 1 : 0", [
@@ -223,6 +282,14 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("exponentiationExpression", () => {
+    assertParse("exponentiationExpression", "2 ** 2 ** 3", [
+      ops.exponentiation,
+      [ops.literal, 2],
+      [ops.exponentiation, [ops.literal, 2], [ops.literal, 3]],
+    ]);
+  });
+
   test("expression", () => {
     assertParse(
       "expression",
@@ -366,6 +433,26 @@ describe("Origami parser", () => {
         [ops.scope, "slug"],
       ],
     ]);
+
+    // Verify parser treatment of identifiers containing operators
+    assertParse("expression", "a + b", [
+      ops.addition,
+      [undetermined, "a"],
+      [undetermined, "b"],
+    ]);
+    assertParse("expression", "a+b", [ops.scope, "a+b"]);
+    assertParse("expression", "a - b", [
+      ops.subtraction,
+      [undetermined, "a"],
+      [undetermined, "b"],
+    ]);
+    assertParse("expression", "a-b", [ops.scope, "a-b"]);
+    assertParse("expression", "a&b", [ops.scope, "a&b"]);
+    assertParse("expression", "a & b", [
+      ops.bitwiseAnd,
+      [undetermined, "a"],
+      [undetermined, "b"],
+    ]);
   });
 
   test("group", () => {
@@ -490,6 +577,24 @@ describe("Origami parser", () => {
     assertParse("multiLineComment", "/*\nHello, world!\n*/", null, false);
   });
 
+  test("multiplicativeExpression", () => {
+    assertParse("multiplicativeExpression", "3 * 4", [
+      ops.multiplication,
+      [ops.literal, 3],
+      [ops.literal, 4],
+    ]);
+    assertParse("multiplicativeExpression", "5 / 2", [
+      ops.division,
+      [ops.literal, 5],
+      [ops.literal, 2],
+    ]);
+    assertParse("multiplicativeExpression", "6 % 5", [
+      ops.remainder,
+      [ops.literal, 6],
+      [ops.literal, 5],
+    ]);
+  });
+
   test("namespace", () => {
     assertParse("namespace", "js:", [ops.builtin, "js:"]);
   });
@@ -510,12 +615,8 @@ describe("Origami parser", () => {
 
   test("numericLiteral", () => {
     assertParse("numericLiteral", "123", [ops.literal, 123]);
-    assertParse("numericLiteral", "-456", [ops.literal, -456]);
     assertParse("numericLiteral", ".5", [ops.literal, 0.5]);
     assertParse("numericLiteral", "123.45", [ops.literal, 123.45]);
-    assertParse("numericLiteral", "-678.90", [ops.literal, -678.9]);
-    assertParse("numericLiteral", "+123", [ops.literal, 123]);
-    assertParse("numericLiteral", "+456.78", [ops.literal, 456.78]);
   });
 
   test("objectLiteral", () => {
@@ -764,6 +865,29 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("relationalExpression", () => {
+    assertParse("relationalExpression", "1 < 2", [
+      ops.lessThan,
+      [ops.literal, 1],
+      [ops.literal, 2],
+    ]);
+    assertParse("relationalExpression", "3 > 4", [
+      ops.greaterThan,
+      [ops.literal, 3],
+      [ops.literal, 4],
+    ]);
+    assertParse("relationalExpression", "5 <= 6", [
+      ops.lessThanOrEqual,
+      [ops.literal, 5],
+      [ops.literal, 6],
+    ]);
+    assertParse("relationalExpression", "7 >= 8", [
+      ops.greaterThanOrEqual,
+      [ops.literal, 7],
+      [ops.literal, 8],
+    ]);
+  });
+
   test("rootDirectory", () => {
     assertParse("rootDirectory", "/", [ops.rootDirectory]);
   });
@@ -775,6 +899,24 @@ describe("Origami parser", () => {
     // assertParse("scopeReference", "markdown/", [ops.scope, "markdown"]);
   });
 
+  test("shiftExpression", () => {
+    assertParse("shiftExpression", "1 << 2", [
+      ops.shiftLeft,
+      [ops.literal, 1],
+      [ops.literal, 2],
+    ]);
+    assertParse("shiftExpression", "3 >> 4", [
+      ops.shiftRightSigned,
+      [ops.literal, 3],
+      [ops.literal, 4],
+    ]);
+    assertParse("shiftExpression", "5 >>> 6", [
+      ops.shiftRightUnsigned,
+      [ops.literal, 5],
+      [ops.literal, 6],
+    ]);
+  });
+
   test("shorthandFunction", () => {
     assertParse("shorthandFunction", "=message", [
       ops.lambda,
@@ -898,6 +1040,9 @@ describe("Origami parser", () => {
       ops.logicalNot,
       [undetermined, "true"],
     ]);
+    assertParse("unaryExpression", "+1", [ops.unaryPlus, [ops.literal, 1]]);
+    assertParse("unaryExpression", "-2", [ops.unaryMinus, [ops.literal, 2]]);
+    assertParse("unaryExpression", "~3", [ops.bitwiseNot, [ops.literal, 3]]);
   });
 });