marko 6.0.94 → 6.0.96

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;
@@ -7967,7 +7967,12 @@ function trackReferencesForBinding(babelBinding, binding) {
   const { referencePaths, constantViolations } = babelBinding;
   for (const ref of referencePaths) {
     const refSection = getOrCreateSection(ref);
-    if (isReferenceHoisted(babelBinding.path, ref)) {
+    const markoRoot = getMarkoRoot(ref);
+    if (markoRoot?.type === "MarkoAttribute" && markoRoot.parentPath === babelBinding.path) {
+      throw ref.buildCodeFrameError(
+        `Tag variable circular references are not supported.`
+      );
+    } else if (isReferenceHoisted(babelBinding.path, ref)) {
       trackHoistedReference(ref, binding);
     } else if (binding.type !== 4 /* local */ || refSection !== binding.section) {
       trackReference(ref, binding);
@@ -7992,12 +7997,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 +8027,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 +8209,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 +8223,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 +8251,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,20 +8439,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);
-        if (binding.section !== fn.section) {
-          addOwnerSerializeReason(fn.section, binding.section, registerReason);
+  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) => {
@@ -8458,7 +8502,7 @@ function finalizeReferences() {
   }
   mergedReferences.clear();
   readsByExpression.clear();
-  readsByFn.clear();
+  fnReadsByExpression.clear();
 }
 function getMaxOwnSourceOffset(intersection, section) {
   let scopeOffset;
@@ -8612,7 +8656,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) {
@@ -8628,11 +8672,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) {
@@ -8768,14 +8815,38 @@ function getReadReplacement(node) {
       replacement = import_compiler35.types.identifier(binding.name);
     }
   } else if (read) {
-    replacement = toMemberExpression(
-      import_compiler35.types.identifier(read.binding.name),
-      Array.isArray(read.props) ? read.props[0] : read.props
-    );
-    if (Array.isArray(read.props)) {
-      for (let i = 1; i < read.props.length; i++) {
-        replacement = toMemberExpression(replacement, read.props[i]);
+    const props = read.props ? Array.isArray(read.props) ? read.props.slice() : [read.props] : [];
+    let curNode = node;
+    let curBinding = read.binding;
+    let replaceMember;
+    replacement = import_compiler35.types.identifier(read.binding.name);
+    while (props.length && (curNode.type === "MemberExpression" || curNode.type === "OptionalMemberExpression")) {
+      const prop = props.pop();
+      const memberProp = getMemberExpressionPropString(curNode);
+      if (memberProp !== prop) break;
+      replaceMember = curNode;
+      curNode = curNode.object;
+    }
+    for (const prop of props) {
+      if (curBinding) {
+        curBinding = curBinding.propertyAliases.get(prop);
+      }
+      replacement = toMemberExpression(
+        replacement,
+        prop,
+        !!curBinding?.nullable
+      );
+    }
+    if (replaceMember) {
+      if (read.binding.nullable && replaceMember.object.type !== replacement.type) {
+        replaceMember.type = "OptionalMemberExpression";
+        replaceMember.optional = true;
       }
+      replaceMember.object = withPreviousLocation(
+        replacement,
+        replaceMember.object
+      );
+      replacement = void 0;
     }
   }
   return replacement && withPreviousLocation(replacement, node);
@@ -8804,13 +8875,70 @@ 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;
+  }
+}
+function findClosestUpstream(from, to) {
+  let closest = from;
+  do {
+    if (closest === to) {
+      return closest;
+    }
+  } while (closest = closest.upstreamAlias);
+}
+function getRootBindings(reads) {
+  let rootRefs;
+  let allBindings;
+  for (const { binding } of reads) {
+    allBindings = bindingUtil.add(allBindings, binding);
+  }
+  for (const { binding } of reads) {
+    let alias = binding.upstreamAlias;
+    while (alias) {
+      if (bindingUtil.has(allBindings, alias)) break;
+      alias = alias.upstreamAlias;
+    }
+    if (!alias) {
+      rootRefs = bindingUtil.add(rootRefs, binding);
+    }
+  }
+  return rootRefs;
+}
 function resolveReferencedBindings(expr, reads, intersectionsBySection) {
   let referencedBindings;
   if (Array.isArray(reads)) {
+    const rootBindings = getRootBindings(reads);
     for (const read of reads) {
       let { binding } = read;
       if (read.node) {
-        const exprReference = (read.node.extra ??= {}).read ??= resolveExpressionReference(reads, binding, void 0);
+        const exprReference = (read.node.extra ??= {}).read ??= resolveExpressionReference(rootBindings, binding);
         ({ binding } = (read.node.extra ??= {}).read = exprReference);
       }
       referencedBindings = bindingUtil.add(referencedBindings, binding);
@@ -8839,38 +8967,29 @@ function resolveReferencedBindings(expr, reads, intersectionsBySection) {
   }
   return referencedBindings;
 }
-function resolveExpressionReference(reads, readBinding, readProps) {
-  const { upstreamAlias } = readBinding;
-  if (upstreamAlias && Array.isArray(reads)) {
-    const prop = getCanonicalProperty(readBinding);
-    const aliasProps = prop === void 0 ? readProps : push(readProps, prop);
-    for (const { binding } of reads) {
-      if (binding !== readBinding) {
-        let alias = upstreamAlias;
-        while (alias) {
-          if (binding === alias) {
-            return resolveExpressionReference(reads, alias, aliasProps);
-          }
-          alias = alias.upstreamAlias;
-        }
-      }
+function resolveExpressionReference(rootBindings, readBinding) {
+  const upstreamRoot = readBinding.upstreamAlias && findClosestReference(readBinding.upstreamAlias, rootBindings);
+  if (!upstreamRoot) {
+    return createRead(readBinding, void 0);
+  }
+  let curBinding = readBinding;
+  let props;
+  while (curBinding !== upstreamRoot) {
+    if (curBinding.property !== void 0) {
+      props = push(props, curBinding.property);
     }
+    curBinding = curBinding.upstreamAlias;
   }
-  return createRead(readBinding, readProps);
+  if (Array.isArray(props)) {
+    props.reverse();
+  }
+  return createRead(upstreamRoot, props);
 }
 function isSupersetSources(a, b) {
   if (!b.sources) return true;
   if (!a.sources) return false;
   return bindingUtil.isSuperset(a.sources.state, b.sources.state) && bindingUtil.isSuperset(a.sources.param, b.sources.param);
 }
-function getCanonicalProperty(binding) {
-  if (binding.property !== void 0) {
-    return binding.property;
-  }
-  if (binding.upstreamAlias && binding.excludeProperties === void 0) {
-    return binding.upstreamAlias.property;
-  }
-}
 function createRead(binding, props) {
   return { binding, props };
 }

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 {
     }
@@ -109,22 +112,20 @@ export declare function getDebugName(binding: Binding): string;
 export declare function getDebugNames(refs: ReferencedBindings): string;
 export declare function getSectionInstancesAccessor(section: Section): string;
 export declare function getSectionInstancesAccessorLiteral(section: Section): t.StringLiteral | t.NumericLiteral | undefined;
-export declare function getReadReplacement(node: t.Identifier | t.MemberExpression | t.OptionalMemberExpression): t.Node | undefined;
+export declare function getReadReplacement(node: t.Identifier | t.MemberExpression | t.OptionalMemberExpression): t.Expression | 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.94",
+  "version": "6.0.96",
   "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"
   },