@weborigami/language 0.0.69 → 0.0.71-beta.1

package/main.js

@@ -11,5 +11,7 @@ export { default as HandleExtensionsTransform } from "./src/runtime/HandleExtens
 export { default as ImportModulesMixin } from "./src/runtime/ImportModulesMixin.js";
 export { default as InvokeFunctionsTransform } from "./src/runtime/InvokeFunctionsTransform.js";
 export { default as OrigamiFiles } from "./src/runtime/OrigamiFiles.js";
+export * as symbols from "./src/runtime/symbols.js";
+export { default as taggedTemplate } from "./src/runtime/taggedTemplate.js";
 export { default as TreeEvent } from "./src/runtime/TreeEvent.js";
 export { default as WatchFilesMixin } from "./src/runtime/WatchFilesMixin.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.0.69",
+  "version": "0.0.71-beta.1",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,8 @@
     "typescript": "5.6.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.69",
-    "@weborigami/types": "0.0.69",
+    "@weborigami/async-tree": "0.0.71-beta.1",
+    "@weborigami/types": "0.0.71-beta.1",
     "watcher": "2.3.1"
   },
   "scripts": {

package/src/compiler/compile.js

@@ -1,18 +1,20 @@
+import { trailingSlash } from "@weborigami/async-tree";
 import { createExpressionFunction } from "../runtime/expressionFunction.js";
+import { ops } from "../runtime/internal.js";
 import { parse } from "./parse.js";
 
 function compile(source, startRule) {
   if (typeof source === "string") {
     source = { text: source };
   }
-  // Trim whitespace from template blocks before we begin lexing, as our
-  // heuristics are non-local and hard to implement in our parser.
-  const preprocessed = trimTemplateWhitespace(source.text);
-  const parseResult = parse(preprocessed, {
+  const code = parse(source.text, {
     grammarSource: source,
     startRule,
   });
-  const fn = createExpressionFunction(parseResult);
+  const cache = {};
+  const modified = cacheNonLocalScopeReferences(code, cache);
+  // const modified = code;
+  const fn = createExpressionFunction(modified);
   return fn;
 }
 
@@ -20,42 +22,63 @@ export function expression(source) {
   return compile(source, "expression");
 }
 
-export function templateDocument(source) {
-  return compile(source, "templateDocument");
+// Given code containing ops.scope calls, upgrade them to ops.cache calls unless
+// they refer to local variables: variables defined by object literals or lambda
+// parameters.
+export function cacheNonLocalScopeReferences(code, cache, locals = {}) {
+  const [fn, ...args] = code;
+
+  let additionalLocalNames;
+  switch (fn) {
+    case ops.scope:
+      const key = args[0];
+      const normalizedKey = trailingSlash.remove(key);
+      if (locals[normalizedKey]) {
+        return code;
+      } else {
+        // Upgrade to cached scope lookup
+        const modified = [ops.cache, key, cache];
+        /** @type {any} */ (modified).location = code.location;
+        return modified;
+      }
+
+    case ops.lambda:
+      const parameters = args[0];
+      additionalLocalNames = parameters;
+      break;
+
+    case ops.object:
+      const entries = args;
+      additionalLocalNames = entries.map(([key]) => trailingSlash.remove(key));
+      break;
+  }
+
+  let updatedLocals = { ...locals };
+  if (additionalLocalNames) {
+    for (const key of additionalLocalNames) {
+      updatedLocals[key] = true;
+    }
+  }
+
+  const modified = code.map((child) => {
+    if (Array.isArray(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 cacheNonLocalScopeReferences(child, cache, updatedLocals);
+    } else {
+      return child;
+    }
+  });
+
+  if (code.location) {
+    modified.location = code.location;
+  }
+  return modified;
 }
 
-// Trim the whitespace around and in substitution blocks in a template. There's
-// no explicit syntax for blocks, but we infer them as any place where a
-// substitution itself contains a multi-line template literal.
-//
-// Example:
-//
-//     ${ if `
-//       true text
-//     `, `
-//       false text
-//     ` }
-//
-// Case 1: a substitution that starts the text or starts a line (there's only
-// whitespace before the `${`), and has the line end with the start of a
-// template literal (there's only whitespace after the backtick) marks the start
-// of a block.
-//
-// Case 2: a line in the middle that ends one template literal and starts
-// another is an internal break in the block. Edge case: three backticks in a
-// row, like ```, are common in markdown and are not treated as a break.
-//
-// Case 3: a line that ends a template literal and ends with `}` or ends the
-// text marks the end of the block.
-//
-// In all three cases, we trim spaces and tabs from the start and end of the
-// line. In case 1, we also remove the preceding newline.
-function trimTemplateWhitespace(text) {
-  const regex1 = /(^|\n)[ \t]*((?:{{|\${).*?`)[ \t]*\n/g;
-  const regex2 = /\n[ \t]*(`(?!`).*?`)[ \t]*\n/g;
-  const regex3js = /\n[ \t]*(`(?!`).*?(?:}}|[^\\]}))[ \t]*(?:\n|$)/g;
-  const trimBlockStarts = text.replace(regex1, "$1$2");
-  const trimBlockBreaks = trimBlockStarts.replace(regex2, "\n$1");
-  const trimBlockEnds = trimBlockBreaks.replace(regex3js, "\n$1");
-  return trimBlockEnds;
+export function templateDocument(source) {
+  return compile(source, "templateDocument");
 }

package/src/compiler/origami.pegjs

@@ -103,7 +103,7 @@ doubleArrow = "⇒" / "=>"
 
 doubleQuoteString "double quote string"
   = '"' chars:doubleQuoteStringChar* '"' {
-    return annotate([ops.primitive, chars.join("")], location());
+    return annotate([ops.literal, chars.join("")], location());
   }
 
 doubleQuoteStringChar
@@ -132,13 +132,21 @@ expression "Origami expression"
 
 float "floating-point number"
   = sign? digits? "." digits {
-      return annotate([ops.primitive, parseFloat(text())], location());
+      return annotate([ops.literal, parseFloat(text())], location());
     }
 
 // Parse a function and its arguments, e.g. `fn(arg)`, possibly part of a chain
 // of function calls, like `fn(arg1)(arg2)(arg3)`.
 functionComposition "function composition"
-  = target:callTarget chain:args* end:implicitParensArgs? {
+  // Function with at least one argument and maybe implicit parens arguments
+  = target:callTarget chain:args+ end:implicitParensArgs? {
+      if (end) {
+        chain.push(end);
+      }
+      return annotate(makeFunctionCall(target, chain, location()), location());
+    }
+  // Function with implicit parens arguments after maybe other arguments
+  / target:callTarget chain:args* end:implicitParensArgs {
       if (end) {
         chain.push(end);
       }
@@ -153,7 +161,7 @@ group "parenthetical group"
 
 guillemetString "guillemet string"
   = '«' chars:guillemetStringChar* '»' {
-    return annotate([ops.primitive, chars.join("")], location());
+    return annotate([ops.literal, chars.join("")], location());
   }
 
 guillemetStringChar
@@ -166,7 +174,7 @@ host "HTTP/HTTPS host"
   = identifier:identifier port:(":" @number)? {
     const portText = port ? `:${port[1]}` : "";
     const hostText = identifier + portText;
-    return annotate([ops.primitive, hostText], location());
+    return annotate([ops.literal, hostText], location());
   }
 
 identifier "identifier"
@@ -195,13 +203,13 @@ inlineSpace
 
 integer "integer"
   = sign? digits {
-      return annotate([ops.primitive, parseInt(text())], location());
+      return annotate([ops.literal, parseInt(text())], location());
     }
 
 // A lambda expression: `=foo()`
 lambda "lambda function"
   = "=" __ expr:expr {
-      return annotate([ops.lambda, null, expr], location());
+      return annotate([ops.lambda, ["_"], expr], location());
     }
 
 // A path that begins with a slash: `/foo/bar`
@@ -277,7 +285,7 @@ objectPublicKey
     return identifier + (slash ?? "");
   }
   / string:string {
-    // Remove `ops.primitive` from the string code
+    // Remove `ops.literal` from the string code
     return string[1];
   }
 
@@ -309,7 +317,7 @@ path "slash-separated path"
 // A path key followed by a slash
 pathElement
   = chars:pathKeyChar* "/" {
-    return annotate([ops.primitive, chars.join("") + "/"], location());
+    return annotate([ops.literal, chars.join("") + "/"], location());
   }
 
 // A single character in a slash-separated path.
@@ -322,7 +330,7 @@ pathKeyChar
 // A path key without a slash
 pathTail
   = chars:pathKeyChar+ {
-    return annotate([ops.primitive, chars.join("")], location());
+    return annotate([ops.literal, chars.join("")], location());
   }
 
 // Parse a protocol call like `fn://foo/bar`.
@@ -354,6 +362,7 @@ scopeReference "scope reference"
 scopeTraverse
   = ref:scopeReference "/" path:path {
       const head = [ops.scope, `${ ref[1] }/`];
+      head.location = ref.location;
       return annotate([ops.traverse, head, ...path], location());
     }
 
@@ -374,7 +383,7 @@ singleLineComment
 
 singleQuoteString "single quote string"
   = "'" chars:singleQuoteStringChar* "'" {
-    return annotate([ops.primitive, chars.join("")], location());
+    return annotate([ops.literal, chars.join("")], location());
   }
 
 singleQuoteStringChar
@@ -402,8 +411,10 @@ step
   / templateLiteral
   / string
   / group
-  // Protocol calls are distinguished by a colon, but it's not at the start.
+  // Things that have a distinctive character, but not at the start
   / protocolCall
+  / taggedTemplate
+  / scopeTraverse
   // Least distinctive option is a simple scope reference, so it comes last.
   / scopeReference
 
@@ -415,11 +426,16 @@ string "string"
   / singleQuoteString
   / guillemetString
 
+taggedTemplate
+  = tag:callTarget "`" contents:templateLiteralContents "`" {
+      return annotate(makeTemplate(tag, contents[0], contents[1]), location());
+    }
+
 // A top-level document defining a template. This is the same as a template
 // literal, but can contain backticks at the top level.
 templateDocument "template"
   = contents:templateDocumentContents {
-      return annotate([ops.lambda, null, contents], location());
+      return annotate([ops.lambda, ["_"], contents], location());
     }
 
 // Template documents can contain backticks at the top level.
@@ -428,19 +444,19 @@ templateDocumentChar
 
 // The contents of a template document containing plain text and substitutions
 templateDocumentContents
-  = parts:(templateDocumentText / templateSubstitution)* {
-      return annotate(makeTemplate(parts), location());
+  = head:templateDocumentText tail:(templateSubstitution templateDocumentText)* {
+      return annotate(makeTemplate(ops.template, head, tail), location());
     }
 
 templateDocumentText "template text"
-  = chars:templateDocumentChar+ {
-    return annotate([ops.primitive, chars.join("")], location());
-  }
+  = chars:templateDocumentChar* {
+      return chars.join("");
+    }
 
 // A backtick-quoted template literal
 templateLiteral "template literal"
   = "`" contents:templateLiteralContents "`" {
-      return annotate(contents, location());
+      return annotate(makeTemplate(ops.template, contents[0], contents[1]), location());
     }
 
 templateLiteralChar
@@ -448,21 +464,17 @@ templateLiteralChar
 
 // The contents of a template literal containing plain text and substitutions
 templateLiteralContents
-  = parts:(templateLiteralText / templateSubstitution)* {
-      return annotate(makeTemplate(parts), location());
-    }
+  = head:templateLiteralText tail:(templateSubstitution templateLiteralText)*
 
 // Plain text in a template literal
 templateLiteralText
-  = chars:templateLiteralChar+ {
-    return annotate([ops.primitive, chars.join("")], location());
-  }
+  = chars:templateLiteralChar* {
+      return chars.join("");
+    }
 
 // A substitution in a template literal: `${x}`
 templateSubstitution "template substitution"
-  = "${" __ expr:expr __ "}" {
-      return annotate(expr, location());
-    }
+  = "${" __ @expr __ "}"
 
 textChar
   = escapedChar