@weborigami/language 0.1.0 → 0.2.1

package/index.ts

@@ -12,6 +12,7 @@ export type Code = Array<any> & {
     start: Position;
     end: Position;
   };
+  source: string;
 };
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -8,15 +8,17 @@
   "devDependencies": {
     "@types/node": "22.7.4",
     "peggy": "4.0.3",
-    "typescript": "5.6.2"
+    "typescript": "5.6.2",
+    "yaml": "2.5.1"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.1.0",
-    "@weborigami/types": "0.1.0",
+    "@weborigami/async-tree": "0.2.1",
+    "@weborigami/types": "0.2.1",
     "watcher": "2.3.1"
   },
   "scripts": {
     "build": "peggy --allowed-start-rules=\"*\" --format es src/compiler/origami.pegjs --output src/compiler/parse.js",
+    "buildTests": "node ./test/generator/generateTests.js",
     "prepublishOnly": "npm run build",
     "test": "node --test --test-reporter=spec",
     "typecheck": "tsc"

package/src/compiler/compile.js

@@ -2,11 +2,11 @@ import { trailingSlash } from "@weborigami/async-tree";
 import { createExpressionFunction } from "../runtime/expressionFunction.js";
 import { ops } from "../runtime/internal.js";
 import { parse } from "./parse.js";
-import { annotate } from "./parserHelpers.js";
+import { annotate, undetermined } from "./parserHelpers.js";
 
 function compile(source, options) {
   const { startRule } = options;
-  const scopeCaching = options.scopeCaching ?? true;
+  const enableCaching = options.scopeCaching ?? true;
   if (typeof source === "string") {
     source = { text: source };
   }
@@ -15,9 +15,7 @@ function compile(source, options) {
     startRule,
   });
   const cache = {};
-  const modified = scopeCaching
-    ? cacheExternalScopeReferences(code, cache)
-    : code;
+  const modified = transformScopeReferences(code, cache, enableCaching);
   const fn = createExpressionFunction(modified);
   return fn;
 }
@@ -29,24 +27,39 @@ export function expression(source, options = {}) {
   });
 }
 
-// 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 cacheExternalScopeReferences(code, cache, locals = {}) {
+// Transform any remaining undetermined references to scope references. At the
+// same time, transform those or explicit ops.scope calls to ops.external calls
+// unless they refer to local variables (variables defined by object literals or
+// lambda parameters).
+export function transformScopeReferences(
+  code,
+  cache,
+  enableCaching,
+  locals = {}
+) {
   const [fn, ...args] = code;
 
   let additionalLocalNames;
   switch (fn) {
+    case undetermined:
     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];
+      if (enableCaching && !locals[normalizedKey]) {
+        // Upgrade to cached external reference
+        const modified = [ops.external, key, cache];
+        // @ts-ignore
+        annotate(modified, code.location);
+        return modified;
+      } else if (fn === undetermined) {
+        // Transform undetermined reference to regular scope call
+        const modified = [ops.scope, key];
+        // @ts-ignore
         annotate(modified, code.location);
         return modified;
+      } else {
+        // Internal ops.scope call; leave as is
+        return code;
       }
 
     case ops.lambda:
@@ -74,7 +87,12 @@ export function cacheExternalScopeReferences(code, cache, locals = {}) {
       // 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 cacheExternalScopeReferences(child, cache, updatedLocals);
+      return transformScopeReferences(
+        child,
+        cache,
+        enableCaching,
+        updatedLocals
+      );
     } else {
       return child;
     }