@weborigami/language 0.3.3-jse.3 → 0.3.3

package/main.js

@@ -7,15 +7,13 @@ export { default as evaluate } from "./src/runtime/evaluate.js";
 export { default as EventTargetMixin } from "./src/runtime/EventTargetMixin.js";
 export * as expressionFunction from "./src/runtime/expressionFunction.js";
 export { default as functionResultsMap } from "./src/runtime/functionResultsMap.js";
-export { default as getHandlers } from "./src/runtime/getHandlers.js";
 export { default as HandleExtensionsTransform } from "./src/runtime/HandleExtensionsTransform.js";
 export * from "./src/runtime/handlers.js";
 export { default as ImportModulesMixin } from "./src/runtime/ImportModulesMixin.js";
 export { default as InvokeFunctionsTransform } from "./src/runtime/InvokeFunctionsTransform.js";
-export { default as jsGlobals } from "./src/runtime/jsGlobals.js";
 export * as moduleCache from "./src/runtime/moduleCache.js";
 export { default as OrigamiFiles } from "./src/runtime/OrigamiFiles.js";
 export * as symbols from "./src/runtime/symbols.js";
-export { default as taggedTemplateIndent } from "./src/runtime/templateIndent.js";
+export { default as taggedTemplateIndent } from "./src/runtime/taggedTemplateIndent.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.3.3-jse.3",
+  "version": "0.3.3",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,8 @@
     "typescript": "5.8.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.3.3-jse.3",
-    "@weborigami/types": "0.3.3-jse.3",
+    "@weborigami/async-tree": "0.3.3",
+    "@weborigami/types": "0.3.3",
     "watcher": "2.3.1",
     "yaml": "2.7.0"
   },

package/src/compiler/compile.js

@@ -1,26 +1,18 @@
 import { createExpressionFunction } from "../runtime/expressionFunction.js";
-import jsGlobals from "../runtime/jsGlobals.js";
 import optimize from "./optimize.js";
 import { parse } from "./parse.js";
 
 function compile(source, options) {
-  const { startRule } = options;
-  const mode = options.mode ?? "shell";
-  const globals = options.globals ?? jsGlobals;
+  const { macros, startRule } = options;
   const enableCaching = options.scopeCaching ?? true;
   if (typeof source === "string") {
     source = { text: source };
   }
   const code = parse(source.text, {
     grammarSource: source,
-    mode,
     startRule,
   });
-  const optimized = optimize(code, {
-    enableCaching,
-    globals,
-    mode,
-  });
+  const optimized = optimize(code, enableCaching, macros);
   const fn = createExpressionFunction(optimized);
   return fn;
 }

package/src/compiler/optimize.js

@@ -1,60 +1,40 @@
 import { pathFromKeys, trailingSlash } from "@weborigami/async-tree";
 import { ops } from "../runtime/internal.js";
-import jsGlobals from "../runtime/jsGlobals.js";
-import { annotate, markers } from "./parserHelpers.js";
+import { annotate, undetermined } from "./parserHelpers.js";
 
 /**
  * Optimize an Origami code instruction:
  *
- * - Transform any remaining reference references to scope references.
+ * - Transform any remaining undetermined references to scope references.
  * - 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).
+ * - Apply any macros to the code.
  *
  * @typedef {import("./parserHelpers.js").AnnotatedCode} AnnotatedCode
  * @typedef {import("./parserHelpers.js").Code} Code
  *
  * @param {AnnotatedCode} code
- * @param {any} options
+ * @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, options = {}) {
-  const enableCaching = options.enableCaching ?? true;
-  const globals = options.globals ?? jsGlobals;
-  const mode = options.mode ?? "shell";
-  const cache = options.cache ?? {};
-
-  // The locals is an array, one item for each function or object context that
-  // has been entered. The array grows to the right. The array items are
-  // subarrays containing the names of local variables defined in that context.
-  const locals = options.locals ? options.locals.slice() : [];
-
-  const externalScope =
-    mode === "shell"
-      ? // External scope is parent scope + globals
-        annotate(
-          [ops.merge, globals, annotate([ops.scope], code.location)],
-          code.location
-        )
-      : annotate([ops.scope], code.location);
-
+export default function optimize(
+  code,
+  enableCaching = true,
+  macros = {},
+  cache = {},
+  locals = {}
+) {
   // See if we can optimize this level of the code
   const [fn, ...args] = code;
-  let optimized = code;
-  let externalReference = fn instanceof Array && fn[0] === ops.scope;
-  let depth;
+  let additionalLocalNames;
   switch (fn) {
-    case markers.global:
-      // Replace global op with the globals
-      optimized = annotate([globals, args[0]], code.location);
-      break;
-
     case ops.lambda:
       const parameters = args[0];
-      if (parameters.length > 0) {
-        const names = parameters.map((param) => param[1]);
-        locals.push(names);
-      }
+      additionalLocalNames = parameters.map((param) => param[1]);
       break;
 
     case ops.literal:
@@ -66,131 +46,97 @@ export default function optimize(code, options = {}) {
 
     case ops.object:
       const entries = args;
-      const keys = entries.map(([key]) => propertyName(key));
-      locals.push(keys);
+      additionalLocalNames = entries.map(([key]) => trailingSlash.remove(key));
       break;
 
-    case markers.reference:
-      // Determine whether reference is local and, if so, transform to
-      // ops.local call. Otherwise transform to ops.scope call.
-      let key = args[0];
-      if (key instanceof Array && key[0] === ops.literal) {
-        key = key[1];
-      }
+    // Both of these are handled the same way
+    case undetermined:
+    case ops.scope:
+      const key = args[0];
       const normalizedKey = trailingSlash.remove(key);
-      let target;
-      depth = getLocalReferenceDepth(locals, normalizedKey);
-      if (depth >= 0) {
-        // Transform local reference
-        const contextCode = [ops.context];
-        if (depth > 0) {
-          contextCode.push(depth);
-        }
-        target = annotate(contextCode, code.location);
-      } else if (mode === "shell") {
-        // Transform non-local reference
-        target = externalScope;
-        externalReference = true;
-      } else if (mode === "jse") {
-        target = globals;
+      if (macros?.[normalizedKey]) {
+        // Apply macro
+        const macro = macros?.[normalizedKey];
+        return applyMacro(macro, code, enableCaching, macros, cache, locals);
+      } else if (enableCaching && !locals[normalizedKey]) {
+        // Upgrade to cached external scope reference
+        return annotate(
+          [ops.external, key, annotate([ops.scope, key], code.location), cache],
+          code.location
+        );
+      } else if (fn === undetermined) {
+        // Transform undetermined reference to regular scope call
+        return annotate([ops.scope, key], code.location);
+      } else {
+        // Internal ops.scope call; leave as is
+        return code;
       }
-      optimized = annotate([target, ...args], code.location);
-      break;
 
-    case ops.scope:
-      depth = locals.length;
-      if (depth === 0) {
-        // Use scope call as is
-        optimized = code;
-      } else {
-        // Add context for appropriate depth to scope call
-        const contextCode = annotate([ops.context, depth], code.location);
-        optimized = annotate([ops.scope, contextCode], code.location);
+    case ops.traverse:
+      // Is the first argument a nonscope/undetermined reference?
+      const isScopeRef =
+        args[0]?.[0] === ops.scope || args[0]?.[0] === undetermined;
+      if (enableCaching && isScopeRef) {
+        // Is the first argument a nonlocal reference?
+        const normalizedKey = trailingSlash.remove(args[0][1]);
+        if (!locals[normalizedKey]) {
+          // Are the remaining arguments all literals?
+          const allLiterals = args
+            .slice(1)
+            .every((arg) => arg[0] === ops.literal);
+          if (allLiterals) {
+            // Convert to ops.external
+            const keys = args.map((arg) => arg[1]);
+            const path = pathFromKeys(keys);
+            /** @type {Code} */
+            const optimized = [ops.external, path, code, cache];
+            return annotate(optimized, code.location);
+          }
+        }
       }
       break;
   }
 
-  // Optimize children
-  optimized = annotate(
-    optimized.map((child, index) => {
-      // Don't optimize lambda parameter names
-      if (fn === ops.lambda && index === 1) {
-        return child;
-      } else if (fn === ops.object && index > 0) {
-        // Code that defines a property `x` that contains references to `x`
-        // shouldn't find this context but look further up.
-        const [key, value] = child;
-        const normalizedKey = trailingSlash.remove(key);
-        let adjustedLocals;
-        if (locals.at(-1)?.includes(normalizedKey)) {
-          adjustedLocals = locals.slice();
-          // Remove the key from the current context's locals
-          adjustedLocals[adjustedLocals.length - 1] = locals
-            .at(-1)
-            .filter((name) => name !== normalizedKey);
-        } else {
-          adjustedLocals = locals;
-        }
-        return [
-          key,
-          optimize(/** @type {AnnotatedCode} */ (value), {
-            ...options,
-            locals: adjustedLocals,
-          }),
-        ];
-      } else if (Array.isArray(child) && "location" in child) {
-        // Review: Aside from ops.object (above), what non-instruction arrays
-        // does this descend into?
-        return optimize(/** @type {AnnotatedCode} */ (child), {
-          ...options,
-          locals,
-        });
-      } else {
-        return child;
-      }
-    }),
-    optimized.location
-  );
+  // Add any locals introduced by this code to the list that will be consulted
+  // when we descend into child nodes.
+  let updatedLocals;
+  if (additionalLocalNames) {
+    updatedLocals = { ...locals };
+    for (const key of additionalLocalNames) {
+      updatedLocals[key] = true;
+    }
+  } else {
+    updatedLocals = locals;
+  }
 
-  // Cache external scope or merged globals + scope references
-  if (enableCaching && externalReference) {
-    // Get all the keys so we can construct a path as a cache key
-    const keys = optimized
-      .slice(1)
-      .map((arg) =>
-        typeof arg === "string" || typeof arg === "number"
-          ? arg
-          : arg instanceof Array && arg[0] === ops.literal
-          ? arg[1]
-          : null
+  // Optimize children
+  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 entries of an ops.object. This should be harmless, but it'd
+      // be preferable to only descend into instructions. This would require
+      // surrounding ops.object entries with ops.array.
+      return optimize(
+        /** @type {AnnotatedCode} */ (child),
+        enableCaching,
+        macros,
+        cache,
+        updatedLocals
       );
-    if (keys.some((key) => key === null)) {
-      throw new Error("Internal error: scope reference with non-literal key");
+    } else {
+      return child;
     }
-    const path = pathFromKeys(keys);
-    optimized = annotate(
-      [ops.cache, cache, path, optimized],
-      optimized.location
-    );
-  }
+  });
 
   return annotate(optimized, code.location);
 }
 
-// Determine how many contexts up we need to go for a local
-function getLocalReferenceDepth(locals, key) {
-  const contextIndex = locals.findLastIndex((names) => names.includes(key));
-  if (contextIndex < 0) {
-    return -1; // Not a local reference
-  }
-  const depth = locals.length - contextIndex - 1;
-  return depth;
-}
-
-function propertyName(key) {
-  if (key[0] === "(" && key[key.length - 1] === ")") {
-    // Non-enumerable property, remove parentheses
-    key = key.slice(1, -1);
-  }
-  return trailingSlash.remove(key);
+function applyMacro(macro, code, enableCaching, macros, cache, locals) {
+  const optimized = optimize(macro, enableCaching, macros, cache, locals);
+  return optimized instanceof Array
+    ? annotate(optimized, code.location)
+    : optimized;
 }