@weborigami/language 0.0.73 → 0.2.0

package/test/compiler/parse.test.js

@@ -1,105 +1,225 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import { parse } from "../../src/compiler/parse.js";
+import { undetermined } from "../../src/compiler/parserHelpers.js";
 import * as ops from "../../src/runtime/ops.js";
 import { stripCodeLocations } from "./stripCodeLocations.js";
 
 describe("Origami parser", () => {
-  test("absoluteFilePath", () => {
-    assertParse("absoluteFilePath", "/foo/bar", [
-      [ops.filesRoot],
-      [ops.literal, "foo/"],
-      [ops.literal, "bar"],
-    ]);
-  });
-
-  test("array", () => {
-    assertParse("array", "[]", [ops.array]);
-    assertParse("array", "[1, 2, 3]", [
+  test("arrayLiteral", () => {
+    assertParse("arrayLiteral", "[]", [ops.array]);
+    assertParse("arrayLiteral", "[1, 2, 3]", [
       ops.array,
       [ops.literal, 1],
       [ops.literal, 2],
       [ops.literal, 3],
     ]);
-    assertParse("array", "[ 1 , 2 , 3 ]", [
+    assertParse("arrayLiteral", "[ 1 , 2 , 3 ]", [
       ops.array,
       [ops.literal, 1],
       [ops.literal, 2],
       [ops.literal, 3],
     ]);
-    assertParse("array", "[ 1, ...[2, 3]]", [
+    assertParse("arrayLiteral", "[ 1, ...[2, 3]]", [
       ops.merge,
       [ops.array, [ops.literal, 1]],
       [ops.array, [ops.literal, 2], [ops.literal, 3]],
     ]);
+    assertParse(
+      "arrayLiteral",
+      `[
+        1
+        2
+        3
+      ]`,
+      [ops.array, [ops.literal, 1], [ops.literal, 2], [ops.literal, 3]]
+    );
   });
 
-  test("expr", () => {
-    assertParse("expr", "obj.json", [ops.scope, "obj.json"]);
-    assertParse("expr", "(fn a, b, c)", [
-      [ops.scope, "fn"],
+  test("arrowFunction", () => {
+    assertParse("arrowFunction", "() => foo", [
+      ops.lambda,
+      [],
+      [ops.scope, "foo"],
+    ]);
+    assertParse("arrowFunction", "(a, b, c) ⇒ fn(a, b, c)", [
+      ops.lambda,
+      ["a", "b", "c"],
+      [
+        [ops.builtin, "fn"],
+        [ops.scope, "a"],
+        [ops.scope, "b"],
+        [ops.scope, "c"],
+      ],
+    ]);
+    assertParse("arrowFunction", "(a) => (b) => fn(a, b)", [
+      ops.lambda,
+      ["a"],
+      [
+        ops.lambda,
+        ["b"],
+        [
+          [ops.builtin, "fn"],
+          [ops.scope, "a"],
+          [ops.scope, "b"],
+        ],
+      ],
+    ]);
+  });
+
+  test("callExpression", () => {
+    assertParse("callExpression", "fn()", [[ops.builtin, "fn"], undefined]);
+    assertParse("callExpression", "foo.js(arg)", [
+      [ops.scope, "foo.js"],
+      [ops.scope, "arg"],
+    ]);
+    assertParse("callExpression", "fn(a, b)", [
+      [ops.builtin, "fn"],
       [ops.scope, "a"],
       [ops.scope, "b"],
-      [ops.scope, "c"],
     ]);
-    assertParse("expr", "foo.bar('hello', 'world')", [
-      [ops.scope, "foo.bar"],
-      [ops.literal, "hello"],
-      [ops.literal, "world"],
+    assertParse("callExpression", "foo.js( a , b )", [
+      [ops.scope, "foo.js"],
+      [ops.scope, "a"],
+      [ops.scope, "b"],
     ]);
-    assertParse("expr", "(fn)('a')", [
-      [ops.scope, "fn"],
-      [ops.literal, "a"],
+    assertParse("callExpression", "fn()(arg)", [
+      [[ops.builtin, "fn"], undefined],
+      [ops.scope, "arg"],
     ]);
-    assertParse("expr", "1", [ops.literal, 1]);
-    assertParse("expr", "{ a: 1, b: 2 }", [
-      ops.object,
-      ["a", [ops.literal, 1]],
-      ["b", [ops.literal, 2]],
+    assertParse("callExpression", "tree/", [ops.unpack, [ops.scope, "tree/"]]);
+    assertParse("callExpression", "tree/foo/bar", [
+      ops.traverse,
+      [ops.scope, "tree/"],
+      [ops.literal, "foo/"],
+      [ops.literal, "bar"],
     ]);
-    assertParse("expr", "serve { index.html: 'hello' }", [
-      [ops.scope, "serve"],
-      [ops.object, ["index.html", [ops.literal, "hello"]]],
+    assertParse("callExpression", "tree/foo/bar/", [
+      ops.traverse,
+      [ops.scope, "tree/"],
+      [ops.literal, "foo/"],
+      [ops.literal, "bar/"],
     ]);
-    assertParse("expr", "fn =`x`", [
-      [ops.scope, "fn"],
-      [ops.lambda, ["_"], [ops.template, [ops.literal, ["x"]]]],
+    assertParse("callExpression", "/foo/bar", [
+      ops.traverse,
+      [ops.rootDirectory, [ops.literal, "foo/"]],
+      [ops.literal, "bar"],
+    ]);
+    assertParse("callExpression", "foo.js()/key", [
+      ops.traverse,
+      [[ops.scope, "foo.js"], undefined],
+      [ops.literal, "key"],
+    ]);
+    assertParse("callExpression", "tree/key()", [
+      [ops.traverse, [ops.scope, "tree/"], [ops.literal, "key"]],
+      undefined,
+    ]);
+    assertParse("callExpression", "(tree)/", [ops.unpack, [ops.scope, "tree"]]);
+    assertParse("callExpression", "fn()/key()", [
+      [ops.traverse, [[ops.builtin, "fn"], undefined], [ops.literal, "key"]],
+      undefined,
+    ]);
+    assertParse("callExpression", "(foo.js())('arg')", [
+      [[ops.scope, "foo.js"], undefined],
+      [ops.literal, "arg"],
     ]);
-    assertParse("expr", "copy app(formulas), files 'snapshot'", [
-      [ops.scope, "copy"],
+    assertParse("callExpression", "fn('a')('b')", [
       [
-        [ops.scope, "app"],
-        [ops.scope, "formulas"],
+        [ops.builtin, "fn"],
+        [ops.literal, "a"],
+      ],
+      [ops.literal, "b"],
+    ]);
+    assertParse("callExpression", "(foo.js())(a, b)", [
+      [[ops.scope, "foo.js"], undefined],
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+    ]);
+    assertParse("callExpression", "{ a: 1, b: 2}/b", [
+      ops.traverse,
+      [ops.object, ["a", [ops.literal, 1]], ["b", [ops.literal, 2]]],
+      [ops.literal, "b"],
+    ]);
+    assertParse("callExpression", "indent`hello`", [
+      [ops.builtin, "indent"],
+      [ops.literal, ["hello"]],
+    ]);
+    assertParse("callExpression", "fn.js`Hello, world.`", [
+      [ops.scope, "fn.js"],
+      [ops.literal, ["Hello, world."]],
+    ]);
+    assertParse("callExpression", "files:src/assets", [
+      ops.traverse,
+      [
+        [ops.builtin, "files:"],
+        [ops.literal, "src/"],
       ],
+      [ops.literal, "assets"],
+    ]);
+    assertParse("callExpression", "new:(js:Date, '2025-01-01')", [
+      [ops.builtin, "new:"],
       [
-        [ops.scope, "files"],
-        [ops.literal, "snapshot"],
+        [ops.builtin, "js:"],
+        [ops.literal, "Date"],
       ],
+      [ops.literal, "2025-01-01"],
     ]);
-    assertParse("expr", "@map =`<li>${_}</li>`", [
-      [ops.scope, "@map"],
+    assertParse("callExpression", "map(markdown, mdHtml)", [
+      [ops.builtin, "map"],
+      [ops.scope, "markdown"],
+      [ops.scope, "mdHtml"],
+    ]);
+    assertParse("callExpression", "package:@weborigami/dropbox/auth(creds)", [
       [
-        ops.lambda,
-        ["_"],
+        ops.traverse,
         [
-          ops.template,
-          [ops.literal, ["<li>", "</li>"]],
-          [ops.concat, [ops.scope, "_"]],
+          [ops.builtin, "package:"],
+          [ops.literal, "@weborigami/"],
         ],
+        [ops.literal, "dropbox/"],
+        [ops.literal, "auth"],
       ],
+      [ops.scope, "creds"],
     ]);
-    assertParse("expr", `"https://example.com"`, [
-      ops.literal,
-      "https://example.com",
+  });
+
+  test("conditionalExpression", () => {
+    assertParse("conditionalExpression", "1", [ops.literal, 1]);
+    assertParse("conditionalExpression", "true ? 1 : 0", [
+      ops.conditional,
+      [ops.scope, "true"],
+      [ops.lambda, [], [ops.literal, "1"]],
+      [ops.lambda, [], [ops.literal, "0"]],
     ]);
-    assertParse("expr", "'Hello' -> test.orit", [
-      [ops.scope, "test.orit"],
-      [ops.literal, "Hello"],
+    assertParse("conditionalExpression", "false ? () => 1 : 0", [
+      ops.conditional,
+      [ops.scope, "false"],
+      [ops.lambda, [], [ops.lambda, [], [ops.literal, "1"]]],
+      [ops.lambda, [], [ops.literal, "0"]],
     ]);
-    assertParse("expr", "tag`Hello, ${name}!`", [
-      [ops.scope, "tag"],
-      [ops.literal, ["Hello, ", "!"]],
-      [ops.concat, [ops.scope, "name"]],
+    assertParse("conditionalExpression", "false ? =1 : 0", [
+      ops.conditional,
+      [ops.scope, "false"],
+      [ops.lambda, [], [ops.lambda, ["_"], [ops.literal, "1"]]],
+      [ops.lambda, [], [ops.literal, "0"]],
+    ]);
+  });
+
+  test("equalityExpression", () => {
+    assertParse("equalityExpression", "1 === 1", [
+      ops.strictEqual,
+      [ops.literal, 1],
+      [ops.literal, 1],
+    ]);
+    assertParse("equalityExpression", "a === b === c", [
+      ops.strictEqual,
+      [ops.strictEqual, [undetermined, "a"], [undetermined, "b"]],
+      [undetermined, "c"],
+    ]);
+    assertParse("equalityExpression", "1 !== 1", [
+      ops.notStrictEqual,
+      [ops.literal, 1],
+      [ops.literal, 1],
     ]);
   });
 
@@ -109,7 +229,7 @@ describe("Origami parser", () => {
       `
         {
           index.html = index.ori(teamData.yaml)
-          thumbnails = @map(images, { value: thumbnail.js })
+          thumbnails = map(images, { value: thumbnail.js })
         }
       `,
       [
@@ -129,7 +249,7 @@ describe("Origami parser", () => {
           [
             ops.getter,
             [
-              [ops.scope, "@map"],
+              [ops.builtin, "map"],
               [ops.scope, "images"],
               [ops.object, ["value", [ops.scope, "thumbnail.js"]]],
             ],
@@ -138,121 +258,128 @@ describe("Origami parser", () => {
       ]
     );
 
+    // Builtin on its own is the function itself, not a function call
+    assertParse("expression", "mdHtml:", [ops.builtin, "mdHtml:"]);
+
     // Consecutive slahes in a path are removed
     assertParse("expression", "path//key", [
       ops.traverse,
       [ops.scope, "path/"],
       [ops.literal, "key"],
     ]);
+
     // Single slash at start of something = absolute file path
     assertParse("expression", "/path", [
-      [ops.filesRoot],
+      ops.rootDirectory,
       [ops.literal, "path"],
     ]);
+
     // Consecutive slashes at start of something = comment
     assertParse("expression", "path //comment", [ops.scope, "path"], false);
-  });
-
-  test("functionComposition", () => {
-    assertParse("functionComposition", "fn()", [[ops.scope, "fn"], undefined]);
-    assertParse("functionComposition", "fn(arg)", [
-      [ops.scope, "fn"],
-      [ops.scope, "arg"],
+    assertParse("expression", "page.ori(mdHtml:(about.md))", [
+      [ops.scope, "page.ori"],
+      [
+        [ops.builtin, "mdHtml:"],
+        [ops.scope, "about.md"],
+      ],
     ]);
-    assertParse("functionComposition", "fn(a, b)", [
-      [ops.scope, "fn"],
-      [ops.scope, "a"],
-      [ops.scope, "b"],
+
+    // Slash on its own is the root folder
+    assertParse("expression", "keys /", [
+      [ops.builtin, "keys"],
+      [ops.rootDirectory],
     ]);
-    assertParse("functionComposition", "fn( a , b )", [
-      [ops.scope, "fn"],
-      [ops.scope, "a"],
-      [ops.scope, "b"],
+
+    assertParse("expression", "'Hello' -> test.orit", [
+      [ops.scope, "test.orit"],
+      [ops.literal, "Hello"],
     ]);
-    assertParse("functionComposition", "fn()(arg)", [
-      [[ops.scope, "fn"], undefined],
-      [ops.scope, "arg"],
+    assertParse("expression", "obj.json", [ops.scope, "obj.json"]);
+    assertParse("expression", "(fn a, b, c)", [
+      [ops.builtin, "fn"],
+      [undetermined, "a"],
+      [undetermined, "b"],
+      [undetermined, "c"],
     ]);
-    assertParse("functionComposition", "fn()/key", [
-      ops.traverse,
-      [[ops.scope, "fn"], undefined],
-      [ops.literal, "key"],
+    assertParse("expression", "foo.bar('hello', 'world')", [
+      [ops.scope, "foo.bar"],
+      [ops.literal, "hello"],
+      [ops.literal, "world"],
     ]);
-    assertParse("functionComposition", "tree/key()", [
-      [ops.traverse, [ops.scope, "tree/"], [ops.literal, "key"]],
-      undefined,
+    assertParse("expression", "(key)('a')", [
+      [ops.scope, "key"],
+      [ops.literal, "a"],
     ]);
-    assertParse("functionComposition", "(tree)/", [
-      ops.unpack,
-      [ops.scope, "tree"],
+    assertParse("expression", "1", [ops.literal, 1]);
+    assertParse("expression", "{ a: 1, b: 2 }", [
+      ops.object,
+      ["a", [ops.literal, 1]],
+      ["b", [ops.literal, 2]],
     ]);
-    assertParse("functionComposition", "fn()/key()", [
-      [ops.traverse, [[ops.scope, "fn"], undefined], [ops.literal, "key"]],
-      undefined,
+    assertParse("expression", "serve { index.html: 'hello' }", [
+      [ops.builtin, "serve"],
+      [ops.object, ["index.html", [ops.literal, "hello"]]],
     ]);
-    assertParse("functionComposition", "(fn())('arg')", [
-      [[ops.scope, "fn"], undefined],
-      [ops.literal, "arg"],
+    assertParse("expression", "fn =`x`", [
+      [ops.builtin, "fn"],
+      [ops.lambda, ["_"], [ops.template, [ops.literal, ["x"]]]],
     ]);
-    assertParse("functionComposition", "fn('a')('b')", [
+    assertParse("expression", "copy app.js(formulas), files:snapshot", [
+      [ops.builtin, "copy"],
       [
-        [ops.scope, "fn"],
-        [ops.literal, "a"],
+        [ops.scope, "app.js"],
+        [ops.scope, "formulas"],
       ],
-      [ops.literal, "b"],
-    ]);
-    assertParse("functionComposition", "(fn())(a, b)", [
-      [[ops.scope, "fn"], undefined],
-      [ops.scope, "a"],
-      [ops.scope, "b"],
-    ]);
-    assertParse("functionComposition", "{ a: 1, b: 2}/b", [
-      ops.traverse,
-      [ops.object, ["a", [ops.literal, 1]], ["b", [ops.literal, 2]]],
-      [ops.literal, "b"],
-    ]);
-    assertParse("functionComposition", "fn arg", [
-      [ops.scope, "fn"],
-      [ops.scope, "arg"],
-    ]);
-    assertParse("functionComposition", "fn 'a', 'b'", [
-      [ops.scope, "fn"],
-      [ops.literal, "a"],
-      [ops.literal, "b"],
-    ]);
-    assertParse("functionComposition", "fn a(b), c", [
-      [ops.scope, "fn"],
       [
-        [ops.scope, "a"],
-        [ops.scope, "b"],
+        [ops.builtin, "files:"],
+        [ops.literal, "snapshot"],
       ],
-      [ops.scope, "c"],
     ]);
-    assertParse("functionComposition", "fn1 fn2 'arg'", [
-      [ops.scope, "fn1"],
+    assertParse("expression", "map =`<li>${_}</li>`", [
+      [ops.builtin, "map"],
       [
-        [ops.scope, "fn2"],
-        [ops.literal, "arg"],
+        ops.lambda,
+        ["_"],
+        [
+          ops.template,
+          [ops.literal, ["<li>", "</li>"]],
+          [ops.concat, [ops.scope, "_"]],
+        ],
       ],
     ]);
-    assertParse("functionComposition", "(fn()) 'arg'", [
-      [[ops.scope, "fn"], undefined],
-      [ops.literal, "arg"],
+    assertParse("expression", `https://example.com/about/`, [
+      [ops.builtin, "https:"],
+      [ops.literal, "example.com/"],
+      [ops.literal, "about/"],
     ]);
-    assertParse("functionComposition", "tree/key arg", [
-      [ops.traverse, [ops.scope, "tree/"], [ops.literal, "key"]],
-      [ops.scope, "arg"],
+    assertParse("expression", "tag`Hello, ${name}!`", [
+      [ops.builtin, "tag"],
+      [ops.literal, ["Hello, ", "!"]],
+      [ops.concat, [ops.scope, "name"]],
     ]);
-    assertParse("functionComposition", "https://example.com/tree.yaml 'key'", [
-      [ops.https, [ops.literal, "example.com"], [ops.literal, "tree.yaml"]],
-      [ops.literal, "key"],
+    assertParse("expression", "(post, slug) => fn.js(post, slug)", [
+      ops.lambda,
+      ["post", "slug"],
+      [
+        [ops.scope, "fn.js"],
+        [ops.scope, "post"],
+        [ops.scope, "slug"],
+      ],
     ]);
   });
 
   test("group", () => {
     assertParse("group", "(hello)", [ops.scope, "hello"]);
     assertParse("group", "(((nested)))", [ops.scope, "nested"]);
-    assertParse("group", "(fn())", [[ops.scope, "fn"], undefined]);
+    assertParse("group", "(fn())", [[ops.builtin, "fn"], undefined]);
+    assertParse("group", "(a -> b)", [
+      [ops.builtin, "b"],
+      [ops.scope, "a"],
+    ]);
+  });
+
+  test("homeDirectory", () => {
+    assertParse("homeDirectory", "~", [ops.homeDirectory]);
   });
 
   test("host", () => {
@@ -268,27 +395,39 @@ describe("Origami parser", () => {
     assertParse("identifier", "x-y-z", "x-y-z", false);
   });
 
-  test("lambda", () => {
-    assertParse("lambda", "=message", [
-      ops.lambda,
-      ["_"],
-      [ops.scope, "message"],
+  test("implicitParenthesesCallExpression", () => {
+    assertParse("implicitParenthesesCallExpression", "fn arg", [
+      [ops.builtin, "fn"],
+      [undetermined, "arg"],
     ]);
-    assertParse("lambda", "=`Hello, ${name}.`", [
-      ops.lambda,
-      ["_"],
+    assertParse("implicitParenthesesCallExpression", "page.ori 'a', 'b'", [
+      [ops.scope, "page.ori"],
+      [ops.literal, "a"],
+      [ops.literal, "b"],
+    ]);
+    assertParse("implicitParenthesesCallExpression", "fn a(b), c", [
+      [ops.builtin, "fn"],
       [
-        ops.template,
-        [ops.literal, ["Hello, ", "."]],
-        [ops.concat, [ops.scope, "name"]],
+        [ops.builtin, "a"],
+        [ops.scope, "b"],
+      ],
+      [undetermined, "c"],
+    ]);
+    assertParse("implicitParenthesesCallExpression", "(fn()) 'arg'", [
+      [[ops.builtin, "fn"], undefined],
+      [ops.literal, "arg"],
+    ]);
+    assertParse("implicitParenthesesCallExpression", "tree/key arg", [
+      [ops.traverse, [ops.scope, "tree/"], [ops.literal, "key"]],
+      [undetermined, "arg"],
+    ]);
+    assertParse("implicitParenthesesCallExpression", "foo.js bar.ori 'arg'", [
+      [ops.scope, "foo.js"],
+      [
+        [ops.scope, "bar.ori"],
+        [ops.literal, "arg"],
       ],
     ]);
-  });
-
-  test("leadingSlashPath", () => {
-    assertParse("leadingSlashPath", "/", []);
-    assertParse("leadingSlashPath", "/tree", [[ops.literal, "tree"]]);
-    assertParse("leadingSlashPath", "/tree/", [[ops.literal, "tree/"]]);
   });
 
   test("list", () => {
@@ -320,83 +459,136 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("logicalAndExpression", () => {
+    assertParse("logicalAndExpression", "true && false", [
+      ops.logicalAnd,
+      [ops.scope, "true"],
+      [ops.lambda, [], [undetermined, "false"]],
+    ]);
+  });
+
+  test("logicalOrExpression", () => {
+    assertParse("logicalOrExpression", "1 || 0", [
+      ops.logicalOr,
+      [ops.literal, 1],
+      [ops.literal, 0],
+    ]);
+    assertParse("logicalOrExpression", "false || false || true", [
+      ops.logicalOr,
+      [ops.scope, "false"],
+      [ops.lambda, [], [undetermined, "false"]],
+      [ops.lambda, [], [undetermined, "true"]],
+    ]);
+    assertParse("logicalOrExpression", "1 || 2 && 0", [
+      ops.logicalOr,
+      [ops.literal, 1],
+      [ops.lambda, [], [ops.logicalAnd, [ops.literal, 2], [ops.literal, 0]]],
+    ]);
+  });
+
   test("multiLineComment", () => {
     assertParse("multiLineComment", "/*\nHello, world!\n*/", null, false);
   });
 
-  test("new", () => {
-    assertParse("expression", "new:@js/Date('2025-01-01')", [
-      [ops.constructor, [ops.literal, "@js"], [ops.literal, "Date"]],
-      [ops.literal, "2025-01-01"],
+  test("namespace", () => {
+    assertParse("namespace", "js:", [ops.builtin, "js:"]);
+  });
+
+  test("nullishCoalescingExpression", () => {
+    assertParse("nullishCoalescingExpression", "a ?? b", [
+      ops.nullishCoalescing,
+      [ops.scope, "a"],
+      [ops.lambda, [], [undetermined, "b"]],
+    ]);
+    assertParse("nullishCoalescingExpression", "a ?? b ?? c", [
+      ops.nullishCoalescing,
+      [ops.scope, "a"],
+      [ops.lambda, [], [undetermined, "b"]],
+      [ops.lambda, [], [undetermined, "c"]],
     ]);
   });
 
-  test("number", () => {
-    assertParse("number", "123", [ops.literal, 123]);
-    assertParse("number", "-456", [ops.literal, -456]);
-    assertParse("number", ".5", [ops.literal, 0.5]);
-    assertParse("number", "123.45", [ops.literal, 123.45]);
-    assertParse("number", "-678.90", [ops.literal, -678.9]);
-    assertParse("number", "+123", [ops.literal, 123]);
-    assertParse("number", "+456.78", [ops.literal, 456.78]);
+  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("object", () => {
-    assertParse("object", "{}", [ops.object]);
-    assertParse("object", "{ a: 1, b }", [
+  test("objectLiteral", () => {
+    assertParse("objectLiteral", "{}", [ops.object]);
+    assertParse("objectLiteral", "{ a: 1, b }", [
       ops.object,
       ["a", [ops.literal, 1]],
       ["b", [ops.inherited, "b"]],
     ]);
-    assertParse("object", "{ sub: { a: 1 } }", [
+    assertParse("objectLiteral", "{ sub: { a: 1 } }", [
       ops.object,
       ["sub", [ops.object, ["a", [ops.literal, 1]]]],
     ]);
-    assertParse("object", "{ sub: { a/: 1 } }", [
+    assertParse("objectLiteral", "{ sub: { a/: 1 } }", [
       ops.object,
       ["sub", [ops.object, ["a/", [ops.literal, 1]]]],
     ]);
-    assertParse("object", `{ "a": 1, "b": 2 }`, [
+    assertParse("objectLiteral", `{ "a": 1, "b": 2 }`, [
       ops.object,
       ["a", [ops.literal, 1]],
       ["b", [ops.literal, 2]],
     ]);
-    assertParse("object", "{ a = b, b = 2 }", [
+    assertParse("objectLiteral", "{ a = b, b = 2 }", [
       ops.object,
       ["a", [ops.getter, [ops.scope, "b"]]],
       ["b", [ops.literal, 2]],
     ]);
-    assertParse("object", "{ a: { b: 1 } }", [
+    assertParse(
+      "objectLiteral",
+      `{
+        a = b
+        b = 2
+      }`,
+      [
+        ops.object,
+        ["a", [ops.getter, [ops.scope, "b"]]],
+        ["b", [ops.literal, 2]],
+      ]
+    );
+    assertParse("objectLiteral", "{ a: { b: 1 } }", [
       ops.object,
       ["a", [ops.object, ["b", [ops.literal, 1]]]],
     ]);
-    assertParse("object", "{ a: { b = 1 } }", [
+    assertParse("objectLiteral", "{ a: { b = 1 } }", [
       ops.object,
       ["a", [ops.object, ["b", [ops.literal, 1]]]],
     ]);
-    assertParse("object", "{ a: { b = fn() } }", [
+    assertParse("objectLiteral", "{ a: { b = fn() } }", [
       ops.object,
-      ["a/", [ops.object, ["b", [ops.getter, [[ops.scope, "fn"], undefined]]]]],
+      [
+        "a/",
+        [ops.object, ["b", [ops.getter, [[ops.builtin, "fn"], undefined]]]],
+      ],
     ]);
-    assertParse("object", "{ x = fn('a') }", [
+    assertParse("objectLiteral", "{ x = fn.js('a') }", [
       ops.object,
       [
         "x",
         [
           ops.getter,
           [
-            [ops.scope, "fn"],
+            [ops.scope, "fn.js"],
             [ops.literal, "a"],
           ],
         ],
       ],
     ]);
-    assertParse("object", "{ a: 1, ...b }", [
+    assertParse("objectLiteral", "{ a: 1, ...b }", [
       ops.merge,
       [ops.object, ["a", [ops.literal, 1]]],
-      [ops.scope, "b"],
+      [undetermined, "b"],
     ]);
-    assertParse("object", "{ (a): 1 }", [
+    assertParse("objectLiteral", "{ (a): 1 }", [
       ops.object,
       ["(a)", [ops.literal, 1]],
     ]);
@@ -410,10 +602,10 @@ describe("Origami parser", () => {
       "a",
       [ops.lambda, ["a"], [ops.scope, "a"]],
     ]);
-    assertParse("objectEntry", "posts/: @map(posts, post.ori)", [
+    assertParse("objectEntry", "posts/: map(posts, post.ori)", [
       "posts/",
       [
-        [ops.scope, "@map"],
+        [ops.builtin, "map"],
         [ops.inherited, "posts"],
         [ops.scope, "post.ori"],
       ],
@@ -425,12 +617,12 @@ describe("Origami parser", () => {
       "data",
       [ops.getter, [ops.scope, "obj.json"]],
     ]);
-    assertParse("objectGetter", "foo = fn 'bar'", [
+    assertParse("objectGetter", "foo = page.ori 'bar'", [
       "foo",
       [
         ops.getter,
         [
-          [ops.scope, "fn"],
+          [ops.scope, "page.ori"],
           [ops.literal, "bar"],
         ],
       ],
@@ -446,7 +638,7 @@ describe("Origami parser", () => {
     assertParse("objectProperty", "x: fn('a')", [
       "x",
       [
-        [ops.scope, "fn"],
+        [ops.builtin, "fn"],
         [ops.literal, "a"],
       ],
     ]);
@@ -458,40 +650,9 @@ describe("Origami parser", () => {
     assertParse("objectPublicKey", "foo\\ bar", "foo bar", false);
   });
 
-  test("parameterizedLambda", () => {
-    assertParse("parameterizedLambda", "() => foo", [
-      ops.lambda,
-      [],
-      [ops.scope, "foo"],
-    ]);
-    assertParse("parameterizedLambda", "(a, b, c) ⇒ fn(a, b, c)", [
-      ops.lambda,
-      ["a", "b", "c"],
-      [
-        [ops.scope, "fn"],
-        [ops.scope, "a"],
-        [ops.scope, "b"],
-        [ops.scope, "c"],
-      ],
-    ]);
-    assertParse("parameterizedLambda", "(a) => (b) => fn(a, b)", [
-      ops.lambda,
-      ["a"],
-      [
-        ops.lambda,
-        ["b"],
-        [
-          [ops.scope, "fn"],
-          [ops.scope, "a"],
-          [ops.scope, "b"],
-        ],
-      ],
-    ]);
-  });
-
-  test("parensArgs", () => {
-    assertParse("parensArgs", "()", [undefined]);
-    assertParse("parensArgs", "(a, b, c)", [
+  test("parenthesesArguments", () => {
+    assertParse("parenthesesArguments", "()", [undefined]);
+    assertParse("parenthesesArguments", "(a, b, c)", [
       [ops.scope, "a"],
       [ops.scope, "b"],
       [ops.scope, "c"],
@@ -499,93 +660,144 @@ describe("Origami parser", () => {
   });
 
   test("path", () => {
-    assertParse("path", "tree/", [[ops.literal, "tree/"]]);
-    assertParse("path", "month/12", [
+    assertParse("path", "/tree/", [[ops.literal, "tree/"]]);
+    assertParse("path", "/month/12", [
       [ops.literal, "month/"],
       [ops.literal, "12"],
     ]);
-    assertParse("path", "tree/foo/bar", [
+    assertParse("path", "/tree/foo/bar", [
       [ops.literal, "tree/"],
       [ops.literal, "foo/"],
       [ops.literal, "bar"],
     ]);
-    assertParse("path", "a///b", [
+    assertParse("path", "/a///b", [
       [ops.literal, "a/"],
       [ops.literal, "b"],
     ]);
   });
 
-  test("pipeline", () => {
-    assertParse("pipeline", "a -> b", [
-      [ops.scope, "b"],
+  test("pathArguments", () => {
+    assertParse("pathArguments", "/", [ops.traverse]);
+    assertParse("pathArguments", "/tree", [
+      ops.traverse,
+      [ops.literal, "tree"],
+    ]);
+    assertParse("pathArguments", "/tree/", [
+      ops.traverse,
+      [ops.literal, "tree/"],
+    ]);
+  });
+
+  test("pipelineExpression", () => {
+    assertParse("pipelineExpression", "foo", [ops.scope, "foo"]);
+    assertParse("pipelineExpression", "a -> b", [
+      [ops.builtin, "b"],
       [ops.scope, "a"],
     ]);
-    assertParse("pipeline", "input → one.js → two.js", [
+    assertParse("pipelineExpression", "input → one.js → two.js", [
       [ops.scope, "two.js"],
       [
         [ops.scope, "one.js"],
         [ops.scope, "input"],
       ],
     ]);
-    assertParse("pipeline", "fn a -> b", [
-      [ops.scope, "b"],
+    assertParse("pipelineExpression", "fn a -> b", [
+      [ops.builtin, "b"],
       [
-        [ops.scope, "fn"],
-        [ops.scope, "a"],
+        [ops.builtin, "fn"],
+        [undetermined, "a"],
       ],
     ]);
   });
 
-  test("protocolCall", () => {
-    assertParse("protocolCall", "foo://bar", [
-      [ops.scope, "foo"],
+  test("primary", () => {
+    assertParse("primary", "foo.js", [ops.scope, "foo.js"]);
+    assertParse("primary", "[1, 2]", [
+      ops.array,
+      [ops.literal, 1],
+      [ops.literal, 2],
+    ]);
+  });
+
+  test("program", () => {
+    assertParse(
+      "program",
+      `#!/usr/bin/env ori invoke
+'Hello'
+`,
+      [ops.literal, "Hello"],
+      false
+    );
+  });
+
+  test("protocolExpression", () => {
+    assertParse("protocolExpression", "foo://bar", [
+      [ops.builtin, "foo:"],
       [ops.literal, "bar"],
     ]);
-    assertParse("protocolCall", "https://example.com/foo/", [
-      ops.https,
+    assertParse("protocolExpression", "http://example.com", [
+      [ops.builtin, "http:"],
       [ops.literal, "example.com"],
-      [ops.literal, "foo/"],
     ]);
-    assertParse("protocolCall", "http:example.com", [
-      ops.http,
-      [ops.literal, "example.com"],
+    assertParse("protocolExpression", "https://example.com/about/", [
+      [ops.builtin, "https:"],
+      [ops.literal, "example.com/"],
+      [ops.literal, "about/"],
+    ]);
+    assertParse("protocolExpression", "https://example.com/about/index.html", [
+      [ops.builtin, "https:"],
+      [ops.literal, "example.com/"],
+      [ops.literal, "about/"],
+      [ops.literal, "index.html"],
     ]);
-    assertParse("protocolCall", "http://localhost:5000/foo", [
-      ops.http,
-      [ops.literal, "localhost:5000"],
+    assertParse("protocolExpression", "http://localhost:5000/foo", [
+      [ops.builtin, "http:"],
+      [ops.literal, "localhost:5000/"],
       [ops.literal, "foo"],
     ]);
   });
 
+  test("qualifiedReference", () => {
+    assertParse("qualifiedReference", "js:Date", [
+      [ops.builtin, "js:"],
+      [ops.literal, "Date"],
+    ]);
+  });
+
+  test("rootDirectory", () => {
+    assertParse("rootDirectory", "/", [ops.rootDirectory]);
+  });
+
   test("scopeReference", () => {
-    assertParse("scopeReference", "x", [ops.scope, "x"]);
+    assertParse("scopeReference", "keys", [undetermined, "keys"]);
+    assertParse("scopeReference", "greet.js", [ops.scope, "greet.js"]);
+    // scopeReference checks whether a slash follows; hard to test in isolation
+    // assertParse("scopeReference", "markdown/", [ops.scope, "markdown"]);
   });
 
-  test("scopeTraverse", () => {
-    assertParse("scopeTraverse", "tree/", [ops.traverse, [ops.scope, "tree/"]]);
-    assertParse("scopeTraverse", "tree/foo/bar", [
-      ops.traverse,
-      [ops.scope, "tree/"],
-      [ops.literal, "foo/"],
-      [ops.literal, "bar"],
+  test("shorthandFunction", () => {
+    assertParse("shorthandFunction", "=message", [
+      ops.lambda,
+      ["_"],
+      [undetermined, "message"],
     ]);
-    assertParse("scopeTraverse", "tree/foo/bar/", [
-      ops.traverse,
-      [ops.scope, "tree/"],
-      [ops.literal, "foo/"],
-      [ops.literal, "bar/"],
+    assertParse("shorthandFunction", "=`Hello, ${name}.`", [
+      ops.lambda,
+      ["_"],
+      [
+        ops.template,
+        [ops.literal, ["Hello, ", "."]],
+        [ops.concat, [ops.scope, "name"]],
+      ],
+    ]);
+    assertParse("shorthandFunction", "=indent`hello`", [
+      ops.lambda,
+      ["_"],
+      [
+        [ops.builtin, "indent"],
+        [ops.literal, ["hello"]],
+      ],
     ]);
-  });
-
-  test("shebang", () => {
-    assertParse(
-      "expression",
-      `#!/usr/bin/env ori @invoke
-'Hello'
-`,
-      [ops.literal, "Hello"],
-      false
-    );
   });
 
   test("singleLineComment", () => {
@@ -593,31 +805,24 @@ describe("Origami parser", () => {
   });
 
   test("spread", () => {
-    assertParse("spread", "...a", [ops.spread, [ops.scope, "a"]]);
-    assertParse("spread", "…a", [ops.spread, [ops.scope, "a"]]);
-  });
-
-  test("string", () => {
-    assertParse("string", '"foo"', [ops.literal, "foo"]);
-    assertParse("string", "'bar'", [ops.literal, "bar"]);
-    assertParse("string", '"foo bar"', [ops.literal, "foo bar"]);
-    assertParse("string", "'bar baz'", [ops.literal, "bar baz"]);
-    assertParse("string", `"foo\\"s bar"`, [ops.literal, `foo"s bar`]);
-    assertParse("string", `'bar\\'s baz'`, [ops.literal, `bar's baz`]);
-    assertParse("string", `«string»`, [ops.literal, "string"]);
-    assertParse("string", `"\\0\\b\\f\\n\\r\\t\\v"`, [
+    assertParse("spread", "...a", [ops.spread, [undetermined, "a"]]);
+    assertParse("spread", "…a", [ops.spread, [undetermined, "a"]]);
+  });
+
+  test("stringLiteral", () => {
+    assertParse("stringLiteral", '"foo"', [ops.literal, "foo"]);
+    assertParse("stringLiteral", "'bar'", [ops.literal, "bar"]);
+    assertParse("stringLiteral", '"foo bar"', [ops.literal, "foo bar"]);
+    assertParse("stringLiteral", "'bar baz'", [ops.literal, "bar baz"]);
+    assertParse("stringLiteral", `"foo\\"s bar"`, [ops.literal, `foo"s bar`]);
+    assertParse("stringLiteral", `'bar\\'s baz'`, [ops.literal, `bar's baz`]);
+    assertParse("stringLiteral", `«string»`, [ops.literal, "string"]);
+    assertParse("stringLiteral", `"\\0\\b\\f\\n\\r\\t\\v"`, [
       ops.literal,
       "\0\b\f\n\r\t\v",
     ]);
   });
 
-  test("taggedTemplate", () => {
-    assertParse("taggedTemplate", "tag`Hello, world.`", [
-      [ops.scope, "tag"],
-      [ops.literal, ["Hello, world."]],
-    ]);
-  });
-
   test("templateDocument", () => {
     assertParse("templateDocument", "hello${foo}world", [
       ops.lambda,
@@ -650,13 +855,13 @@ describe("Origami parser", () => {
       [ops.literal, ["", ""]],
       [ops.concat, [ops.template, [ops.literal, ["nested"]]]],
     ]);
-    assertParse("templateLiteral", "`${map(people, =`${name}`)}`", [
+    assertParse("templateLiteral", "`${ map:(people, =`${name}`) }`", [
       ops.template,
       [ops.literal, ["", ""]],
       [
         ops.concat,
         [
-          [ops.scope, "map"],
+          [ops.builtin, "map:"],
           [ops.scope, "people"],
           [
             ops.lambda,
@@ -687,6 +892,13 @@ describe("Origami parser", () => {
       false
     );
   });
+
+  test("unaryExpression", () => {
+    assertParse("unaryExpression", "!true", [
+      ops.logicalNot,
+      [undetermined, "true"],
+    ]);
+  });
 });
 
 function assertParse(startRule, source, expected, checkLocation = true) {
@@ -699,7 +911,7 @@ function assertParse(startRule, source, expected, checkLocation = true) {
   // entire source. We skip this check in cases where the source starts or ends
   // with a comment; the parser will strip those.
   if (checkLocation) {
-    assert(code.location);
+    assert(code.location, "no location");
     const resultSource = code.location.source.text.slice(
       code.location.start.offset,
       code.location.end.offset