marko 6.0.93 → 6.0.95

package/dist/translator/index.js

@@ -4207,7 +4207,7 @@ function replaceAssignedNode(node) {
             return getBuildAssignment(extra)?.(
               extra.section,
               bindingUtil.has(
-                extra.fnExtra?.referencedBindingsInFunction,
+                extra.assignmentFunction.referencedBindingsInFunction,
                 extra.assignment
               ) ? node : node.operator === "=" ? node.right : import_compiler22.types.binaryExpression(
                 node.operator.slice(
@@ -4237,7 +4237,7 @@ function replaceAssignedNode(node) {
                 );
                 if (builtAssignment) {
                   if (!bindingUtil.has(
-                    extra.fnExtra?.referencedBindingsInFunction,
+                    extra.assignmentFunction.referencedBindingsInFunction,
                     extra.assignment
                   )) {
                     id.name = uid;
@@ -7992,12 +7992,24 @@ function trackReferencesForBinding(babelBinding, binding) {
 }
 function trackAssignment(assignment, binding) {
   const fnRoot = getFnRoot(assignment);
-  const fnExtra = fnRoot && (fnRoot.node.extra ??= {});
   const section = getOrCreateSection(assignment);
   setReferencesScope(assignment);
   forEachIdentifierPath(assignment, (id) => {
     if (id.node.name === binding.name) {
-      const extra = id.node.extra ??= {};
+      if (!fnRoot) {
+        throw id.buildCodeFrameError(
+          `Assignments to a tag ${binding.type === 3 /* param */ ? "parameter" : "variable"} must be within a script or function.`
+        );
+      }
+      const fnExtra = fnRoot && (fnRoot.node.extra ??= {});
+      const idExtra = id.node.extra ??= {};
+      idExtra.assignment = binding;
+      idExtra.assignmentFunction = fnExtra;
+      fnExtra.section = idExtra.section = section;
+      binding.assignmentSections = sectionUtil.add(
+        binding.assignmentSections,
+        section
+      );
       if (binding.upstreamAlias && binding.property !== void 0) {
         const changePropName = binding.property + "Change";
         const changeBinding = binding.upstreamAlias.propertyAliases.get(changePropName) || createBinding(
@@ -8010,16 +8022,9 @@ function trackAssignment(assignment, binding) {
           id.node.loc,
           true
         );
-        extra.assignmentTo = changeBinding;
+        idExtra.assignmentTo = changeBinding;
         addReadToExpression(id, changeBinding);
       }
-      binding.assignmentSections = sectionUtil.add(
-        binding.assignmentSections,
-        section
-      );
-      extra.assignment = binding;
-      extra.section = section;
-      extra.fnExtra = fnExtra;
     }
   });
 }
@@ -8199,12 +8204,13 @@ function compareIntersections(a, b) {
 function finalizeReferences() {
   const bindings = getBindings();
   const readsByExpression = getReadsByExpression();
-  const readsByFn = getReadsByFunction();
+  const fnReadsByExpression = getFunctionReadsByExpression();
   const mergedReferences = getMergedReferences();
   if (mergedReferences.size) {
     for (const [target, nodes] of mergedReferences) {
       const targetExtra = target.extra;
       let reads = readsByExpression.get(targetExtra);
+      let exprFnReads = fnReadsByExpression.get(targetExtra);
       let { isEffect } = targetExtra;
       for (const node of nodes) {
         const extra = node?.extra;
@@ -8212,11 +8218,24 @@ function finalizeReferences() {
           setCanonicalExtra(extra, targetExtra);
           if (isReferencedExtra(extra)) {
             const additionalReads = readsByExpression.get(extra);
+            const additionalExprFnReads = fnReadsByExpression.get(extra);
             isEffect ||= extra.isEffect;
             if (additionalReads) {
               reads = concat(reads, additionalReads);
               readsByExpression.delete(extra);
             }
+            if (additionalExprFnReads) {
+              if (exprFnReads) {
+                for (const [key, value] of additionalExprFnReads) {
+                  exprFnReads.set(key, value);
+                }
+              } else {
+                fnReadsByExpression.set(
+                  targetExtra,
+                  exprFnReads = new Map(additionalExprFnReads)
+                );
+              }
+            }
           }
         }
       }
@@ -8227,14 +8246,25 @@ function finalizeReferences() {
   const intersectionsBySection = /* @__PURE__ */ new Map();
   for (const [expr, reads] of readsByExpression) {
     if (isReferencedExtra(expr)) {
-      expr.referencedBindings = resolveReferencedBindings(
-        expr,
-        reads,
-        intersectionsBySection
-      );
-      forEach(expr.referencedBindings, (binding) => {
-        binding.downstreamExpressions.add(expr);
-      });
+      const referencedBindings = expr.referencedBindings = resolveReferencedBindings(expr, reads, intersectionsBySection);
+      if (referencedBindings) {
+        forEach(referencedBindings, (binding) => {
+          binding.downstreamExpressions.add(expr);
+        });
+        const exprFnReads = fnReadsByExpression.get(expr);
+        if (exprFnReads) {
+          for (const [fn, fnReads] of exprFnReads) {
+            if (fn === expr) {
+              expr.referencedBindingsInFunction = referencedBindings;
+            } else {
+              fn.referencedBindingsInFunction = resolveReferencedBindingsInFunction(
+                referencedBindings,
+                fnReads
+              );
+            }
+          }
+        }
+      }
     }
   }
   for (const binding of bindings) {
@@ -8404,18 +8434,29 @@ function finalizeReferences() {
     });
   });
   finalizeFunctionRegistry();
-  for (const [fn, reads] of readsByFn) {
-    const { registerReason } = fn;
-    fn.referencedBindingsInFunction = resolveReferencedBindings(
-      fn,
-      reads,
-      intersectionsBySection
-    );
-    if (registerReason) {
-      forEach(
-        fn.referencedBindingsInFunction,
-        (binding) => addSerializeReason(binding.section, registerReason, binding)
-      );
+  const referencedExprs = /* @__PURE__ */ new Set();
+  for (const binding of bindings) {
+    for (const expr of binding.downstreamExpressions) {
+      referencedExprs.add(expr);
+    }
+  }
+  for (const expr of referencedExprs) {
+    const exprFnReads = fnReadsByExpression.get(expr);
+    if (exprFnReads) {
+      for (const fn of exprFnReads.keys()) {
+        if (fn.registerReason) {
+          forEach(fn.referencedBindingsInFunction, (binding) => {
+            addSerializeReason(binding.section, fn.registerReason, binding);
+            if (binding.section !== fn.section) {
+              addOwnerSerializeReason(
+                fn.section,
+                binding.section,
+                fn.registerReason
+              );
+            }
+          });
+        }
+      }
     }
   }
   forEachSectionReverse((section) => {
@@ -8456,7 +8497,7 @@ function finalizeReferences() {
   }
   mergedReferences.clear();
   readsByExpression.clear();
-  readsByFn.clear();
+  fnReadsByExpression.clear();
 }
 function getMaxOwnSourceOffset(intersection, section) {
   let scopeOffset;
@@ -8610,7 +8651,7 @@ var propsUtil = new Sorted(function compareProps(a, b) {
 var [getReadsByExpression] = createProgramState(
   () => /* @__PURE__ */ new Map()
 );
-var [getReadsByFunction] = createProgramState(
+var [getFunctionReadsByExpression] = createProgramState(
   () => /* @__PURE__ */ new Map()
 );
 function addReadToExpression(root, binding) {
@@ -8626,11 +8667,14 @@ function addReadToExpression(root, binding) {
     push(readsByExpression.get(exprExtra), read)
   );
   if (fnRoot) {
-    const readsByFn = getReadsByFunction();
+    const fnReadsByExpr = getFunctionReadsByExpression();
+    let exprFnReads = fnReadsByExpr.get(exprExtra);
+    if (!exprFnReads) {
+      fnReadsByExpr.set(exprExtra, exprFnReads = /* @__PURE__ */ new Map());
+    }
     const fnExtra = fnRoot.node.extra ??= {};
-    exprExtra.fnExtra = fnExtra;
     fnExtra.section = section;
-    readsByFn.set(fnExtra, push(readsByFn.get(fnExtra), read));
+    exprFnReads.set(fnExtra, push(exprFnReads.get(fnExtra), read));
   }
 }
 function dropReferences(node) {
@@ -8802,6 +8846,45 @@ function pruneBinding(bindings, binding) {
   }
   return shouldPrune;
 }
+function resolveReferencedBindingsInFunction(refs, reads) {
+  if (reads) {
+    if (Array.isArray(reads)) {
+      let referencedBindings;
+      for (const read of reads) {
+        referencedBindings = bindingUtil.add(
+          referencedBindings,
+          findClosestReference(read.binding, refs)
+        );
+      }
+      return referencedBindings;
+    } else {
+      return findClosestReference(reads.binding, refs);
+    }
+  }
+}
+function findClosestReference(from, refs) {
+  if (Array.isArray(refs)) {
+    if (bindingUtil.has(refs, from)) {
+      return from;
+    }
+    for (const ref of refs) {
+      const closest = findClosestUpstream(from, ref);
+      if (closest) return closest;
+    }
+  } else {
+    const closest = findClosestUpstream(from, refs);
+    if (closest) return closest;
+  }
+  throw new Error("Unable to resolve closest binding reference.");
+}
+function findClosestUpstream(from, to) {
+  let closest = from;
+  do {
+    if (closest === to) {
+      return closest;
+    }
+  } while (closest = closest.upstreamAlias);
+}
 function resolveReferencedBindings(expr, reads, intersectionsBySection) {
   let referencedBindings;
   if (Array.isArray(reads)) {

package/dist/translator/util/references.d.ts

@@ -49,9 +49,8 @@ export interface ParamBinding extends Binding {
 }
 export type ReferencedBindings = Opt<Binding>;
 export type Intersection = Many<Binding>;
-type FnExtra = (t.FunctionExpressionExtra | t.ArrowFunctionExpressionExtra | t.FunctionDeclarationExtra) & {
-    section: Section;
-};
+interface ReferencedFunctionExtra extends t.FunctionExtra, ReferencedExtra {
+}
 declare module "@marko/compiler/dist/types" {
     interface NodeExtra {
         section?: Section;
@@ -69,7 +68,11 @@ declare module "@marko/compiler/dist/types" {
         [kIsInvoked]?: true;
     }
     interface FunctionExtra {
+        referencesScope?: boolean;
         referencedBindingsInFunction?: ReferencedBindings;
+        name?: string;
+        registerId?: string;
+        registerReason?: SerializeReason;
     }
     interface ArrowFunctionExpressionExtra extends FunctionExtra {
     }
@@ -112,19 +115,17 @@ export declare function getSectionInstancesAccessorLiteral(section: Section): t.
 export declare function getReadReplacement(node: t.Identifier | t.MemberExpression | t.OptionalMemberExpression): t.Node | undefined;
 export interface ReferencedExtra extends t.NodeExtra {
     section: Section;
-    fnExtra?: FnExtra;
 }
 export declare function isReferencedExtra(extra: t.NodeExtra | undefined): extra is ReferencedExtra;
 export interface AssignedBindingExtra extends ReferencedExtra {
     assignment: Binding;
+    assignmentFunction: ReferencedFunctionExtra;
 }
 export declare function isAssignedBindingExtra(extra: t.NodeExtra | undefined): extra is AssignedBindingExtra;
-export interface RegisteredFnExtra extends ReferencedExtra {
+export interface RegisteredFnExtra extends ReferencedExtra, t.FunctionExtra {
+    name: string;
     registerId: string;
     registerReason: SerializeReason;
-    name: string;
-    referencesScope?: boolean;
-    referencedBindingsInFunction: ReferencedBindings;
 }
 export declare function isRegisteredFnExtra(extra: t.NodeExtra | undefined): extra is RegisteredFnExtra;
 export declare function getCanonicalExtra<T extends t.NodeExtra>(extra: T): T;

package/dist/translator/visitors/function.d.ts

@@ -1,22 +1,4 @@
 import { types as t } from "@marko/compiler";
-import { type SerializeReason } from "../util/serialize-reasons";
-declare module "@marko/compiler/dist/types" {
-    interface FunctionDeclarationExtra {
-        registerId?: string;
-        registerReason?: SerializeReason;
-        name?: string;
-    }
-    interface FunctionExpressionExtra {
-        registerId?: string;
-        registerReason?: SerializeReason;
-        name?: string;
-    }
-    interface ArrowFunctionExpressionExtra {
-        registerId?: string;
-        registerReason?: SerializeReason;
-        name?: string;
-    }
-}
 declare const _default: {
     analyze(this: unknown, fn: t.NodePath<t.Function>): void;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.0.93",
+  "version": "6.0.95",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -48,7 +48,7 @@
     "build": "node -r ~ts ./scripts/bundle.ts"
   },
   "dependencies": {
-    "@marko/compiler": "^5.39.40",
+    "@marko/compiler": "^5.39.41",
     "csstype": "^3.1.3",
     "magic-string": "^0.30.17"
   },