@weborigami/language 0.5.2 → 0.5.4

package/src/compiler/parserHelpers.js

@@ -455,8 +455,12 @@ export function makeUnaryOperation(operator, value, location) {
     "+": ops.unaryPlus,
     "-": ops.unaryMinus,
     "~": ops.bitwiseNot,
+    await: null, // no-op
+    typeof: ops.typeOf,
+    void: ops.voidOp,
   };
-  return annotate([operators[operator], value], location);
+  const op = operators[operator];
+  return op ? annotate([op, value], location) : annotate(value, location);
 }
 
 /**

package/src/runtime/jsGlobals.js

@@ -191,52 +191,56 @@ async function importWrapper(modulePath) {
  * Origami evaluate() function calls all functions with the evaluation context
  * -- the tree in which the code is running -- as the call target.
  *
- * This function works around the problem. If the indicated classFn has no
- * static methods, it's returned as is. If it does have static methods, this
- * returns an extension of the classFn prototype that overrides the static
- * methods with ones that are bound to the class.
+ * This function works around the problem. If the indicated object has no static
+ * methods, it's returned as is. If it does have static methods, this returns an
+ * extension of the object that overrides the static methods with ones that are
+ * bound to the object.
  */
-function bindStaticMethodsForClass(fn) {
+function bindStaticMethods(obj) {
+  if (typeof obj !== "function" && (typeof obj !== "object" || obj === null)) {
+    // Something like `NaN` or `null`
+    return obj;
+  }
+
   const staticMethodDescriptors = Object.entries(
-    Object.getOwnPropertyDescriptors(fn)
+    Object.getOwnPropertyDescriptors(obj)
   )
     .filter(([key, descriptor]) => descriptor.value instanceof Function)
     .map(([key, descriptor]) => [
       key,
       {
         ...descriptor,
-        value: descriptor.value.bind(fn),
+        value: descriptor.value.bind(obj),
       },
     ]);
   if (staticMethodDescriptors.length === 0) {
     // No static methods
-    return fn;
+    return obj;
   }
 
   let extended;
-  if (!fn.prototype) {
-    // A function like Proxy
-    extended = Object.create(fn);
+  // A regular object or an oddball like Proxy with no prototype
+  if (typeof obj === "object" || !obj.prototype) {
+    extended = Object.create(obj);
   } else {
     /** @this {any} */
     extended = function (...args) {
       const calledWithNew = this instanceof extended;
-      return calledWithNew ? new fn(...args) : fn(...args);
+      return calledWithNew ? new obj(...args) : obj(...args);
     };
   }
 
-  return Object.defineProperties(
+  Object.defineProperties(
     extended,
     Object.fromEntries(staticMethodDescriptors)
   );
+
+  return extended;
 }
 
 function bindStaticMethodsForGlobals(objects) {
   const entries = Object.entries(objects);
-  const bound = entries.map(([key, value]) => [
-    key,
-    value instanceof Function ? bindStaticMethodsForClass(value) : value,
-  ]);
+  const bound = entries.map(([key, value]) => [key, bindStaticMethods(value)]);
   return Object.fromEntries(bound);
 }
 

package/src/runtime/ops.js

@@ -547,6 +547,18 @@ export async function templateText(strings, ...values) {
 }
 addOpLabel(templateText, "«ops.templateText»");
 
+/**
+ * Emulate the JavaScript `typeof` operator
+ *
+ * Note the name is `typeOf` (uppercase "O"), as `typeof` is a reserved word
+ *
+ * @param {any} value
+ */
+export function typeOf(value) {
+  return typeof value;
+}
+addOpLabel(typeOf, "«ops.typeOf»");
+
 export function unaryMinus(a) {
   return -a;
 }
@@ -567,3 +579,13 @@ export async function unpack(value) {
   return isUnpackable(value) ? value.unpack() : value;
 }
 addOpLabel(unpack, "«ops.unpack»");
+
+/**
+ * Emulate JavaScript's rarely-used `void` operator
+ *
+ * @param {any} value
+ */
+export function voidOp(value) {
+  return undefined;
+}
+addOpLabel(voidOp, "«ops.voidOp»");

package/test/compiler/parse.test.js

@@ -155,6 +155,11 @@ describe("Origami parser", () => {
         ],
       ],
     ]);
+    assertParse("arrowFunction", "async (x) => x", [
+      ops.lambda,
+      [[ops.literal, "x"]],
+      [markers.traverse, [markers.reference, "x"]],
+    ]);
   });
 
   test("bitwiseAndExpression", () => {
@@ -1565,6 +1570,9 @@ Body text`,
     assertParse("unaryExpression", "+1", [ops.unaryPlus, [ops.literal, 1]]);
     assertParse("unaryExpression", "-2", [ops.unaryMinus, [ops.literal, 2]]);
     assertParse("unaryExpression", "~3", [ops.bitwiseNot, [ops.literal, 3]]);
+    assertParse("unaryExpression", "typeof 1", [ops.typeOf, [ops.literal, 1]]);
+    assertParse("unaryExpression", "void 0", [ops.voidOp, [ops.literal, 0]]);
+    assertParse("unaryExpression", "await 2", [ops.literal, 2]);
   });
 
   test("unaryOperator", () => {

package/test/runtime/ops.test.js

@@ -414,6 +414,17 @@ describe("ops", () => {
     assert.strictEqual(ops.subtraction(5, true), 4);
   });
 
+  test("ops.typeOf emulates JavaScript typeof", () => {
+    assert.strictEqual(ops.typeOf(true), "boolean");
+    assert.strictEqual(ops.typeOf(1), "number");
+    assert.strictEqual(ops.typeOf("hi"), "string");
+    assert.strictEqual(ops.typeOf(undefined), "undefined");
+    assert.strictEqual(
+      ops.typeOf(() => null),
+      "function"
+    );
+  });
+
   test("ops.unaryMinus", () => {
     assert.strictEqual(ops.unaryMinus(4), -4);
     assert.strictEqual(ops.unaryMinus(-4), 4);
@@ -431,6 +442,12 @@ describe("ops", () => {
     const result = await ops.unpack.call(null, fixture);
     assert.strictEqual(result, "unpacked");
   });
+
+  test("ops.voidOp returns undefined", () => {
+    assert.strictEqual(ops.voidOp(123), undefined);
+    assert.strictEqual(ops.voidOp("hello"), undefined);
+    assert.strictEqual(ops.voidOp(null), undefined);
+  });
 });
 
 function errorFn() {