@weborigami/language 0.2.7 → 0.2.9

package/index.ts

@@ -3,16 +3,24 @@ import { Packed } from "@weborigami/async-tree";
 export * from "./main.js";
 
 /**
- * A chunk of compiled Origami code. This is just an array with an additional
- * `location` property.
+ * Code annotated to track the original source that produced the code. If the
+ * code is an array, it must have a `location` property.
  */
-export type Code = Array<any> & {
-  location: {
-    source: Source;
-    start: Position;
-    end: Position;
-  };
-  source: string;
+export type AnnotatedCodeItem<T = any> = T extends any[] ? never : T;
+export type AnnotatedCode = (AnnotatedCode | AnnotatedCodeItem)[] & {
+  location: CodeLocation
+  source?: string;
+};
+
+/**
+ * A chunk of compiled Origami code. This is just an array.
+ */
+export type Code = Array<any>;
+
+export type CodeLocation = {
+  end: Position;
+  source: Source;
+  start: Position;
 };
 
 /**

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@weborigami/language",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "22.10.2",
+    "@types/node": "22.13.5",
     "peggy": "4.2.0.",
-    "typescript": "5.7.2",
-    "yaml": "2.6.1"
+    "typescript": "5.8.2",
+    "yaml": "2.7.0"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.2.7",
-    "@weborigami/types": "0.2.7",
+    "@weborigami/async-tree": "0.2.9",
+    "@weborigami/types": "0.2.9",
     "watcher": "2.3.1"
   },
   "scripts": {

package/src/compiler/optimize.js

@@ -10,6 +10,16 @@ import { annotate, undetermined } from "./parserHelpers.js";
  *   they refer to local variables (variables defined by object literals or
  *   lambda parameters).
  * - Apply any macros to the code.
+ *
+ * @typedef {import("./parserHelpers.js").AnnotatedCode} AnnotatedCode
+ * @typedef {import("./parserHelpers.js").Code} Code
+ *
+ * @param {AnnotatedCode} code
+ * @param {boolean} enableCaching
+ * @param {Record<string, AnnotatedCode>} macros
+ * @param {Record<string, AnnotatedCode>} cache
+ * @param {Record<string, boolean>} locals
+ * @returns {AnnotatedCode}
  */
 export default function optimize(
   code,
@@ -27,6 +37,13 @@ export default function optimize(
       additionalLocalNames = parameters;
       break;
 
+    case ops.literal:
+      const value = args[0];
+      if (!(value instanceof Array)) {
+        return value;
+      }
+      break;
+
     case ops.object:
       const entries = args;
       additionalLocalNames = entries.map(([key]) => trailingSlash.remove(key));
@@ -43,16 +60,13 @@ export default function optimize(
         return applyMacro(macro, code, enableCaching, macros, cache, locals);
       } else if (enableCaching && !locals[normalizedKey]) {
         // Upgrade to cached external scope reference
-        const optimized = [ops.external, key, [ops.scope, key], cache];
-        // @ts-ignore
-        annotate(optimized, code.location);
-        return optimized;
+        return annotate(
+          [ops.external, key, [ops.scope, key], cache],
+          code.location
+        );
       } else if (fn === undetermined) {
         // Transform undetermined reference to regular scope call
-        const optimized = [ops.scope, key];
-        // @ts-ignore
-        annotate(optimized, code.location);
-        return optimized;
+        return annotate([ops.scope, key], code.location);
       } else {
         // Internal ops.scope call; leave as is
         return code;
@@ -74,10 +88,9 @@ export default function optimize(
             // Convert to ops.external
             const keys = args.map((arg) => arg[1]);
             const path = pathFromKeys(keys);
+            /** @type {Code} */
             const optimized = [ops.external, path, code, cache];
-            // @ts-ignore
-            annotate(optimized, code.location);
-            return optimized;
+            return annotate(optimized, code.location);
           }
         }
       }
@@ -98,27 +111,30 @@ export default function optimize(
 
   // Optimize children
   const optimized = code.map((child) => {
-    if (Array.isArray(child)) {
+    if (Array.isArray(child) && "location" in child) {
       // Review: This currently descends into arrays that are not instructions,
       // such as the parameters of a lambda. This should be harmless, but it'd
       // be preferable to only descend into instructions. This would require
       // surrounding ops.lambda parameters with ops.literal, and ops.object
       // entries with ops.array.
-      return optimize(child, enableCaching, macros, cache, updatedLocals);
+      return optimize(
+        /** @type {AnnotatedCode} */ (child),
+        enableCaching,
+        macros,
+        cache,
+        updatedLocals
+      );
     } else {
       return child;
     }
   });
 
-  if (code.location) {
-    annotate(optimized, code.location);
-  }
-  return optimized;
+  return annotate(optimized, code.location);
 }
 
 function applyMacro(macro, code, enableCaching, macros, cache, locals) {
   const optimized = optimize(macro, enableCaching, macros, cache, locals);
-  // @ts-ignore
-  annotate(optimized, code.location);
-  return optimized;
+  return optimized instanceof Array
+    ? annotate(optimized, code.location)
+    : optimized;
 }

package/src/compiler/origami.pegjs

@@ -37,7 +37,7 @@ __
 
 additiveExpression
   = head:multiplicativeExpression tail:(whitespace @additiveOperator whitespace @multiplicativeExpression)* {
-      return annotate(tail.reduce(makeBinaryOperation, head), location());
+      return tail.reduce(makeBinaryOperation, head);
     }
 
 additiveOperator
@@ -51,7 +51,7 @@ arguments "function arguments"
 
 arrayLiteral "array"
   = "[" __ entries:arrayEntries? __ closingBracket {
-      return annotate(makeArray(entries ?? []), location());
+      return makeArray(entries ?? [], location());
     }
 
 // A separated list of array entries
@@ -70,16 +70,18 @@ arrayEntry
 
 arrowFunction
   = "(" __ parameters:identifierList? __ ")" __ doubleArrow __ pipeline:pipelineExpression {
-      return annotate([ops.lambda, parameters ?? [], pipeline], location());
+      const lambdaParameters = annotate(parameters ?? [], location());
+      return annotate([ops.lambda, lambdaParameters, pipeline], location());
     }
   / identifier:identifier __ doubleArrow __ pipeline:pipelineExpression {
-      return annotate([ops.lambda, [identifier], pipeline], location());
+      const lambdaParameters = annotate([identifier], location())
+      return annotate([ops.lambda, lambdaParameters, pipeline], location());
     }
   / conditionalExpression
 
 bitwiseAndExpression
   = head:equalityExpression tail:(__ @bitwiseAndOperator __ @equalityExpression)* {
-      return annotate(tail.reduce(makeBinaryOperation, head), location());
+      return tail.reduce(makeBinaryOperation, head);
     }
 
 bitwiseAndOperator
@@ -87,7 +89,7 @@ bitwiseAndOperator
 
 bitwiseOrExpression
   = head:bitwiseXorExpression tail:(__ @bitwiseOrOperator __ @bitwiseXorExpression)* {
-      return annotate(tail.reduce(makeBinaryOperation, head), location());
+      return tail.reduce(makeBinaryOperation, head);
     }
 
 bitwiseOrOperator
@@ -95,7 +97,7 @@ bitwiseOrOperator
 
 bitwiseXorExpression
   = head:bitwiseAndExpression tail:(__ @bitwiseXorOperator __ @bitwiseAndExpression)* {
-      return annotate(tail.reduce(makeBinaryOperation, head), location());
+      return tail.reduce(makeBinaryOperation, head);
     }
 
 bitwiseXorOperator
@@ -105,7 +107,7 @@ bitwiseXorOperator
 // `fn(arg1)(arg2)(arg3)`.
 callExpression "function call"
   = head:protocolExpression tail:arguments* {
-      return annotate(tail.reduce(makeCall, head), location());
+      return tail.reduce(makeCall, head);
     }
 
 // Required closing curly brace. We use this for the `object` term: if the
@@ -154,11 +156,12 @@ conditionalExpression
       if (!tail) {
         return condition;
       }
+      const deferred = makeDeferredArguments(tail);
       return annotate([
         ops.conditional,
         downgradeReference(condition),
-        [ops.lambda, [], downgradeReference(tail[0])],
-        [ops.lambda, [], downgradeReference(tail[1])]
+        downgradeReference(deferred[0]),
+        downgradeReference(deferred[1])
       ], location());
     }
   
@@ -179,7 +182,7 @@ ellipsis = "..." / "…" // Unicode ellipsis
 
 equalityExpression
   = head:relationalExpression tail:(__ @equalityOperator __ @relationalExpression)* {
-      return annotate(tail.reduce(makeBinaryOperation, head), location());
+      return tail.reduce(makeBinaryOperation, head);
     }
 
 equalityOperator
@@ -311,7 +314,7 @@ multiLineComment
 
 multiplicativeExpression
   = head:exponentiationExpression tail:(whitespace @multiplicativeOperator whitespace @exponentiationExpression)* {
-      return annotate(tail.reduce(makeBinaryOperation, head), location());
+      return tail.reduce(makeBinaryOperation, head);
     }
 
 multiplicativeOperator
@@ -320,10 +323,9 @@ multiplicativeOperator
   / "%"
 
 // A namespace reference is a string of letters only, followed by a colon.
-// For the time being, we also allow a leading `@`, which is deprecated.
 namespace
-  = at:"@"? chars:[A-Za-z]+ ":" {
-    return annotate([ops.builtin, (at ?? "") + chars.join("") + ":"], location());
+  = chars:[A-Za-z]+ ":" {
+    return annotate([ops.builtin, chars.join("") + ":"], location());
   }
 
 newLine
@@ -349,7 +351,7 @@ nullishCoalescingExpression
 // An object literal: `{foo: 1, bar: 2}`
 objectLiteral "object literal"
   = "{" __ entries:objectEntries? __ closingBrace {
-      return annotate(makeObject(entries ?? [], ops.object), location());
+      return makeObject(entries ?? [], location());
     }
 
 // A separated list of object entries
@@ -389,7 +391,8 @@ objectProperty "object property"
 // A shorthand reference inside an object literal: `foo`
 objectShorthandProperty "object identifier"
   = key:objectPublicKey {
-      return annotate([key, [ops.inherited, key]], location());
+      const inherited = annotate([ops.inherited, key], location());
+      return annotate([key, inherited], location());
     }
 
 objectPublicKey
@@ -456,7 +459,7 @@ primary
   / objectLiteral
   / group
   / templateLiteral
-  / reference
+  / inherited
 
 // Top-level Origami progam with possible shebang directive (which is ignored)
 program "Origami program"
@@ -464,9 +467,9 @@ program "Origami program"
 
 // Protocol with double-slash path: `https://example.com/index.html`
 protocolExpression
-  = fn:namespace "//" host:host path:path? {
+  = fn:namespace "//" host:(host / slash) path:path? {
       const keys = annotate([host, ...(path ?? [])], location());
-      return annotate(makeCall(fn, keys), location());
+      return makeCall(fn, keys);
     }
   / primary
 
@@ -474,10 +477,10 @@ protocolExpression
 qualifiedReference
   = fn:namespace reference:scopeReference {
       const literal = annotate([ops.literal, reference[1]], reference.location);
-      return annotate(makeCall(fn, [literal]), location());
+      return makeCall(fn, [literal]);
     }
 
-reference
+inherited
   = rootDirectory
   / homeDirectory
   / qualifiedReference
@@ -486,7 +489,7 @@ reference
 
 relationalExpression
   = head:shiftExpression tail:(__ @relationalOperator __ @shiftExpression)* {
-      return annotate(tail.reduce(makeBinaryOperation, head), location());
+      return tail.reduce(makeBinaryOperation, head);
     }
 
 relationalOperator
@@ -515,19 +518,12 @@ separator
   = __ "," __
   / whitespaceWithNewLine
 
-// Check whether next character is a slash without consuming input
-slashFollows
-  // This expression returned `undefined` if successful; we convert to `true`
-  = &"/" {
-      return true;
-    }
-
 shebang
   = "#!" [^\n\r]* { return null; }
 
 shiftExpression
   = head:additiveExpression tail:(__ @shiftOperator __ @additiveExpression)* {
-      return annotate(tail.reduce(makeBinaryOperation, head), location());
+      return tail.reduce(makeBinaryOperation, head);
     }
 
 shiftOperator
@@ -539,7 +535,8 @@ shiftOperator
 shorthandFunction "lambda function"
   // Avoid a following equal sign (for an equality)
   = "=" !"=" __ definition:implicitParenthesesCallExpression {
-      return annotate([ops.lambda, ["_"], definition], location());
+      const lambdaParameters = annotate(["_"], location());
+      return annotate([ops.lambda, lambdaParameters, definition], location());
     }
   / implicitParenthesesCallExpression
 
@@ -558,6 +555,19 @@ singleQuoteString "single quote string"
 singleQuoteStringChar
   = !("'" / newLine) @textChar
 
+// Used for an initial slash in a protocol expression
+slash
+  = slashFollows {
+    return annotate([ops.literal, "/"], location());
+  }
+
+// Check whether next character is a slash without consuming input
+slashFollows
+  // This expression returned `undefined` if successful; we convert to `true`
+  = &"/" {
+      return true;
+    }
+
 spreadElement
   = ellipsis __ value:pipelineExpression {
       return annotate([ops.spread, value], location());
@@ -572,8 +582,9 @@ stringLiteral "string"
 // literal, but can contain backticks at the top level.
 templateDocument "template"
   = head:templateDocumentText tail:(templateSubstitution templateDocumentText)* {
+      const lambdaParameters = annotate(["_"], location());
       return annotate(
-        [ops.lambda, ["_"], makeTemplate(ops.templateIndent, head, tail)],
+        [ops.lambda, lambdaParameters, makeTemplate(ops.templateIndent, head, tail, location())],
         location()
       );
     }
@@ -584,13 +595,13 @@ templateDocumentChar
 
 templateDocumentText "template text"
   = chars:templateDocumentChar* {
-      return chars.join("");
+      return annotate([ops.literal, chars.join("")], location());
     }
 
 // A backtick-quoted template literal
 templateLiteral "template literal"
   = "`" head:templateLiteralText tail:(templateSubstitution templateLiteralText)* "`" {
-      return annotate(makeTemplate(ops.template, head, tail), location());
+      return makeTemplate(ops.template, head, tail, location());
     }
 
 templateLiteralChar
@@ -599,7 +610,7 @@ templateLiteralChar
 // Plain text in a template literal
 templateLiteralText
   = chars:templateLiteralChar* {
-      return chars.join("");
+      return annotate([ops.literal, chars.join("")], location());
     }
 
 // A substitution in a template literal: `${x}`
@@ -615,7 +626,7 @@ textChar
 // A unary prefix operator: `!x`
 unaryExpression
   = operator:unaryOperator __ expression:unaryExpression {
-      return annotate(makeUnaryOperation(operator, expression), location());
+      return makeUnaryOperation(operator, expression, location());
     }
   / callExpression
 

package/src/compiler/parse.d.ts

@@ -1,3 +1,3 @@
-import { Code } from "../../index.ts";
+import { AnnotatedCode } from "../../index.ts";
 
-export function parse(input: string, options: any): Code;
+export function parse(input: string, options: any): AnnotatedCode;