@weborigami/language 0.2.9 → 0.2.10

package/package.json

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

package/src/compiler/optimize.js

@@ -34,7 +34,7 @@ export default function optimize(
   switch (fn) {
     case ops.lambda:
       const parameters = args[0];
-      additionalLocalNames = parameters;
+      additionalLocalNames = parameters.map((param) => param[1]);
       break;
 
     case ops.literal:
@@ -61,7 +61,7 @@ export default function optimize(
       } else if (enableCaching && !locals[normalizedKey]) {
         // Upgrade to cached external scope reference
         return annotate(
-          [ops.external, key, [ops.scope, key], cache],
+          [ops.external, key, annotate([ops.scope, key], code.location), cache],
           code.location
         );
       } else if (fn === undetermined) {
@@ -110,13 +110,15 @@ export default function optimize(
   }
 
   // Optimize children
-  const optimized = code.map((child) => {
-    if (Array.isArray(child) && "location" in child) {
+  const optimized = code.map((child, index) => {
+    // Don't optimize lambda parameter names
+    if (fn === ops.lambda && index === 1) {
+      return child;
+    } else 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
+      // such as the entries of an ops.object. 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.
+      // surrounding ops.object entries with ops.array.
       return optimize(
         /** @type {AnnotatedCode} */ (child),
         enableCaching,

package/src/compiler/origami.pegjs

@@ -50,7 +50,7 @@ arguments "function arguments"
   / templateLiteral
 
 arrayLiteral "array"
-  = "[" __ entries:arrayEntries? __ closingBracket {
+  = "[" __ entries:arrayEntries? __ expectClosingBracket {
       return makeArray(entries ?? [], location());
     }
 
@@ -69,13 +69,12 @@ arrayEntry
     }
 
 arrowFunction
-  = "(" __ parameters:identifierList? __ ")" __ doubleArrow __ pipeline:pipelineExpression {
-      const lambdaParameters = annotate(parameters ?? [], location());
+  = "(" __ parameters:parameterList? __ ")" __ doubleArrow __ pipeline:expectPipelineExpression {
+      const lambdaParameters = parameters ?? annotate([], location());
       return annotate([ops.lambda, lambdaParameters, pipeline], location());
     }
-  / identifier:identifier __ doubleArrow __ pipeline:pipelineExpression {
-      const lambdaParameters = annotate([identifier], location())
-      return annotate([ops.lambda, lambdaParameters, pipeline], location());
+  / parameter:parameterSingleton __ doubleArrow __ pipeline:expectPipelineExpression {
+      return annotate([ops.lambda, parameter, pipeline], location());
     }
   / conditionalExpression
 
@@ -110,30 +109,6 @@ callExpression "function call"
       return tail.reduce(makeCall, head);
     }
 
-// Required closing curly brace. We use this for the `object` term: if the
-// parser sees a left curly brace, here we must see a right curly brace.
-closingBrace
-  = "}"
-  / .? {
-      error(`An object ended without a closing brace, or contained something that wasn't expected.\nThe top level of an object can only contain definitions ("a: b" or "a = b") or spreads ("...a").`);
-    }
-
-// Required closing bracket
-closingBracket
-  = "]"
-  / .? {
-      error("Expected right bracket");
-    }
-
-// Required closing parenthesis. We use this for the `group` term: it's the last
-// term in the `step` parser that starts with a parenthesis, so if that parser
-// sees a left parenthesis, here we must see a right parenthesis.
-closingParenthesis
-  = ")"
-  / .? {
-      error("Expected right parenthesis");
-    }
-
 // A comma-separated list of expressions: `x, y, z`
 commaExpression
   // The commas are required, but the list can have a single item.
@@ -171,7 +146,7 @@ digits
 doubleArrow = "⇒" / "=>"
 
 doubleQuoteString "double quote string"
-  = '"' chars:doubleQuoteStringChar* '"' {
+  = '"' chars:doubleQuoteStringChar* expectDoubleQuote {
     return annotate([ops.literal, chars.join("")], location());
   }
 
@@ -201,6 +176,55 @@ escapedChar "backslash-escaped character"
   / "\\v" { return "\v"; }
   / "\\" @.
 
+expectBacktick
+  = "`"
+  / .? {
+      error("Expected closing backtick");
+    }
+
+expectClosingBrace
+  = "}"
+  / .? {
+      error(`An object ended without a closing brace, or contained something that wasn't expected.\nThe top level of an object can only contain definitions ("a: b" or "a = b") or spreads ("...a").`);
+    }
+
+expectClosingBracket
+  = "]"
+  / .? {
+      error("Expected right bracket");
+    }
+
+expectClosingParenthesis
+  = ")"
+  / .? {
+      error("Expected right parenthesis");
+    }
+
+expectDoubleQuote
+  = '"'
+  / .? {
+      error("Expected closing quote");
+    }
+
+expectGuillemet
+  = '»'
+  / .? {
+      error("Expected closing guillemet");
+    }
+
+expectSingleQuote
+  = "'"
+  / .? {
+      error("Expected closing quote");
+    }
+
+// Required expression
+expectPipelineExpression
+  = pipelineExpression
+  / .? {
+      error("Expected an expression");
+    }
+
 exponentiationExpression
   = left:unaryExpression right:(__ "**" __ @exponentiationExpression)? {
       return right ? annotate([ops.exponentiation, left, right], location()) : left;
@@ -217,12 +241,12 @@ floatLiteral "floating-point number"
 
 // An expression in parentheses: `(foo)`
 group "parenthetical group"
-  = "(" expression:expression closingParenthesis {
+  = "(" expression:expression expectClosingParenthesis {
       return annotate(downgradeReference(expression), location());
     }
 
 guillemetString "guillemet string"
-  = '«' chars:guillemetStringChar* '»' {
+  = '«' chars:guillemetStringChar* expectGuillemet {
     return annotate([ops.literal, chars.join("")], location());
   }
 
@@ -254,11 +278,6 @@ identifierChar
   / @'-' !'>' // Accept a hyphen but not in a single arrow combination
   / escapedChar
 
-identifierList
-  = list:identifier|1.., separator| separator? {
-      return annotate(list, location());
-    }
-
 implicitParenthesesCallExpression "function call with implicit parentheses"
   = head:arrowFunction args:(inlineSpace+ @implicitParensthesesArguments)? {
       return args ? makeCall(head, args) : head;
@@ -350,7 +369,7 @@ nullishCoalescingExpression
 
 // An object literal: `{foo: 1, bar: 2}`
 objectLiteral "object literal"
-  = "{" __ entries:objectEntries? __ closingBrace {
+  = "{" __ entries:objectEntries? __ expectClosingBrace {
       return makeObject(entries ?? [], location());
     }
 
@@ -368,7 +387,7 @@ objectEntry
 
 // A getter definition inside an object literal: `foo = 1`
 objectGetter "object getter"
-  = key:objectKey __ "=" __ pipeline:pipelineExpression {
+  = key:objectKey __ "=" __ pipeline:expectPipelineExpression {
       return annotate(
         makeProperty(key, annotate([ops.getter, pipeline], location())),
         location()
@@ -384,7 +403,7 @@ objectKey "object key"
 
 // A property definition in an object literal: `x: 1`
 objectProperty "object property"
-  = key:objectKey __ ":" __ pipeline:pipelineExpression {
+  = key:objectKey __ ":" __ pipeline:expectPipelineExpression {
       return annotate(makeProperty(key, pipeline), location());
     }
 
@@ -404,9 +423,28 @@ objectPublicKey
     return string[1];
   }
 
+parameter
+  = identifier:identifier {
+      return annotate([ops.literal, identifier], location());
+    }
+
+parameterList
+  = list:parameter|1.., separator| separator? {
+      return annotate(list, location());
+    }
+
+// A list with a single identifier
+parameterSingleton
+  = identifier:identifier {
+      return annotate(
+        [annotate([ops.literal, identifier], location())],
+        location()
+      );
+    }
+
 // Function arguments in parentheses
 parenthesesArguments "function arguments in parentheses"
-  = "(" __ list:list? __ ")" {
+  = "(" __ list:list? __ expectClosingParenthesis {
       return annotate(list ?? [undefined], location());
     }
 
@@ -535,7 +573,10 @@ shiftOperator
 shorthandFunction "lambda function"
   // Avoid a following equal sign (for an equality)
   = "=" !"=" __ definition:implicitParenthesesCallExpression {
-      const lambdaParameters = annotate(["_"], location());
+      const lambdaParameters = annotate(
+        [annotate([ops.literal, "_"], location())],
+        location()
+      );
       return annotate([ops.lambda, lambdaParameters, definition], location());
     }
   / implicitParenthesesCallExpression
@@ -548,7 +589,7 @@ singleLineComment
   = "//" [^\n\r]* { return null; }
 
 singleQuoteString "single quote string"
-  = "'" chars:singleQuoteStringChar* "'" {
+  = "'" chars:singleQuoteStringChar* expectSingleQuote {
     return annotate([ops.literal, chars.join("")], location());
   }
 
@@ -582,7 +623,10 @@ stringLiteral "string"
 // literal, but can contain backticks at the top level.
 templateDocument "template"
   = head:templateDocumentText tail:(templateSubstitution templateDocumentText)* {
-      const lambdaParameters = annotate(["_"], location());
+      const lambdaParameters = annotate(
+        [annotate([ops.literal, "_"], location())],
+        location()
+      );
       return annotate(
         [ops.lambda, lambdaParameters, makeTemplate(ops.templateIndent, head, tail, location())],
         location()
@@ -600,7 +644,7 @@ templateDocumentText "template text"
 
 // A backtick-quoted template literal
 templateLiteral "template literal"
-  = "`" head:templateLiteralText tail:(templateSubstitution templateLiteralText)* "`" {
+  = "`" head:templateLiteralText tail:(templateSubstitution templateLiteralText)* expectBacktick {
       return makeTemplate(ops.template, head, tail, location());
     }