@scriptc/compiler 0.0.32 → 0.0.34

package/dist/frontend/types.js

@@ -55,6 +55,20 @@ const PARSE_ARGS_DYN_TYPES = new Set([
 export function isParseArgsDynTypeName(name) {
     return PARSE_ARGS_DYN_TYPES.has(name);
 }
+function priorityRank(priority) {
+    return "rank" in priority ? priority.rank : priority;
+}
+function comparePriority(left, right) {
+    const a = priorityRank(left);
+    const b = priorityRank(right);
+    const length = Math.max(a.length, b.length);
+    for (let i = 0; i < length; i++) {
+        const d = (a[i] ?? 0) - (b[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
 /** The frontend's record-shape interner. Records are monomorphic structural
  * shapes: fields sorted by name form the canonical identity, and two types
  * with the same canonical field list share one shapeId (and later one C
@@ -63,6 +77,19 @@ export function isParseArgsDynTypeName(name) {
 export class ShapeRegistry {
     byKey = new Map();
     byId = new Map();
+    /** Historical emit-order rank of the declaration-order metadata each
+     * shape kept. Collection runs at rank 0; retained reachability bodies
+     * install their old emit positions while they lower. This lets a body
+     * reached after an init replace metadata the worklist encountered first
+     * when the old emitter would have lowered that body first. */
+    declaredOrderPriority = new Map();
+    declaredOrderCandidates = new Map();
+    /** Derived shapes whose order is inherited from another shape. The
+     * source can settle after the derived shape was interned (notably
+     * Partial<T> inside a retained generic body), so refresh the adopted
+     * writer after all priority candidates have closed. */
+    derivedDeclaredOrderFinalizers = [];
+    currentDeclaredOrderPriority = [0, 0];
     /** All interned shapes in first-seen (`r0`, `r1`, ...) order. */
     shapes = [];
     /** ts.Types currently being mapped — a BACK-REFERENCE to one of these is
@@ -94,6 +121,77 @@ export class ShapeRegistry {
             (indexValue ? `idx<${typeKey(indexValue)}>!` : "") +
             JSON.stringify(fields.map((f) => [f.name, typeKey(f.type)])));
     }
+    /** Runs one lowering unit under its historical emit-order rank. Shape
+     * ids remain demand-assigned; only first-seen declaration-order metadata
+     * uses this rank, because Object.keys/JSON/inspect observe it. */
+    withDeclaredOrderPriority(priority, fn) {
+        const previous = this.currentDeclaredOrderPriority;
+        this.currentDeclaredOrderPriority = priority;
+        try {
+            return fn();
+        }
+        finally {
+            this.currentDeclaredOrderPriority = previous;
+        }
+    }
+    adoptDeclaredOrder(shape, declaredOrder) {
+        if (declaredOrder === undefined)
+            return;
+        const candidates = this.declaredOrderCandidates.get(shape.id);
+        const candidate = { order: declaredOrder, priority: this.currentDeclaredOrderPriority };
+        if (candidates)
+            candidates.push(candidate);
+        else
+            this.declaredOrderCandidates.set(shape.id, [candidate]);
+        const previous = this.declaredOrderPriority.get(shape.id);
+        if (previous !== undefined && comparePriority(previous, this.currentDeclaredOrderPriority) <= 0) {
+            return;
+        }
+        shape.declaredOrder = declaredOrder;
+        this.declaredOrderPriority.set(shape.id, this.currentDeclaredOrderPriority);
+    }
+    /** Mutable generic-instance ranks settle only after reachability closes.
+     * Re-choose each shape's first historical writer from the retained
+     * candidates before derived metadata and helper bodies finalize. */
+    settleDeclaredOrderPriorities() {
+        for (const [shapeId, candidates] of this.declaredOrderCandidates) {
+            let best = candidates[0];
+            if (!best)
+                continue;
+            for (const candidate of candidates.slice(1)) {
+                if (comparePriority(candidate.priority, best.priority) < 0)
+                    best = candidate;
+            }
+            const shape = this.byId.get(shapeId);
+            if (!shape)
+                continue;
+            shape.declaredOrder = best.order;
+            this.declaredOrderPriority.set(shapeId, best.priority);
+        }
+        for (const finalize of this.derivedDeclaredOrderFinalizers)
+            finalize();
+    }
+    /** Tracks a derived shape that inherits its key order unchanged from a
+     * source shape. Identity-gating preserves first-writer-wins when an
+     * equivalent derived shape was already adopted from another source. */
+    inheritDeclaredOrder(shapeId, originalOrder, sourceShapeId) {
+        this.derivedDeclaredOrderFinalizers.push(this.declaredOrderFinalizer(shapeId, originalOrder, () => this.get(sourceShapeId)?.declaredOrder));
+    }
+    /** Captures the current historical rank for a derived shape whose order
+     * must be recomputed after retained reachability settles its source. */
+    declaredOrderFinalizer(shapeId, originalOrder, order) {
+        return () => {
+            const shape = this.byId.get(shapeId);
+            // Only the writer whose array the shape actually adopted may revise
+            // it. Another structurally-equal type at the same historical rank
+            // still obeys first-writer-wins.
+            if (shape?.declaredOrder !== originalOrder)
+                return;
+            const next = order();
+            if (next !== undefined)
+                shape.declaredOrder = next;
+        };
+    }
     /** The shape id a back-reference to an in-progress type resolves to:
      * reuses the type's persistent recursive id or mints a PLACEHOLDER
      * entry (empty fields) the outer frame finalizes. */
@@ -134,8 +232,7 @@ export class ShapeRegistry {
             shape.fields = fields;
             if (indexValue)
                 shape.indexValue = indexValue;
-            if (declaredOrder)
-                shape.declaredOrder = declaredOrder;
+            this.adoptDeclaredOrder(shape, declaredOrder);
             this.pendingRec.delete(id);
             const key = this.keyOf(fields, false, indexValue);
             if (!this.byKey.has(key))
@@ -169,6 +266,15 @@ export class ShapeRegistry {
             this.byKey.set(key, id);
             this.byId.set(id, shape);
             this.shapes.push(shape);
+            if (declaredOrder !== undefined) {
+                this.declaredOrderCandidates.set(id, [
+                    { order: declaredOrder, priority: this.currentDeclaredOrderPriority },
+                ]);
+                this.declaredOrderPriority.set(id, this.currentDeclaredOrderPriority);
+            }
+        }
+        else {
+            this.adoptDeclaredOrder(this.byId.get(id), declaredOrder);
         }
         return id;
     }
@@ -565,9 +671,11 @@ function genChannels(yieldTs, retTs, nextTs, ctx) {
  * fallback for it. */
 const MAP_TYPE_MAX_DEPTH = 64;
 let mapTypeDepth = 0;
-/** Bumped whenever mapType resolves a type through CONTEXT-SENSITIVE hooks
- * (a generic body's type parameter, a mixin instantiation) — mappings that
- * make the same ts.Type answer differently across instantiation contexts.
+/** Bumped whenever mapType resolves a type through CONTEXT-SENSITIVE or
+ * collection-sensitive hooks (a generic body's type parameter, a mixin
+ * instantiation, a generic class instance) — mappings that can make the same
+ * ts.Type answer differently across instantiation contexts or collection
+ * phases.
  * The recursive-shape machinery keys shape identity by checker type, which
  * is sound only for context-FREE mappings: a recursive frame that observes
  * a bump between entry and exit stays fenced (recursive generic-open types
@@ -576,9 +684,27 @@ let contextResolutions = 0;
 export function mapType(type, ctx) {
     if (mapTypeDepth >= MAP_TYPE_MAX_DEPTH)
         return null;
+    const topLevel = mapTypeDepth === 0;
+    const typeId = type.id;
+    const memoizable = typeId !== undefined && (ctx.canMemoizeType?.() ?? true);
+    const memoKey = memoizable ? `${ctx.dynamic ? 1 : 0}:${typeId}` : null;
+    if (memoKey !== null) {
+        const memo = ctx.typeMemo?.get(memoKey);
+        if (memo !== undefined)
+            return memo;
+    }
+    const sensitivityAtEntry = contextResolutions;
     mapTypeDepth++;
     try {
-        return mapTypeInner(type, ctx);
+        const mapped = mapTypeInner(type, ctx);
+        if (mapped !== null &&
+            memoKey !== null &&
+            topLevel &&
+            contextResolutions === sensitivityAtEntry &&
+            (ctx.canMemoizeType?.() ?? true)) {
+            ctx.typeMemo?.set(memoKey, mapped);
+        }
+        return mapped;
     }
     finally {
         mapTypeDepth--;
@@ -1054,7 +1180,15 @@ function mapTypeInner(type, ctx) {
         // INSTANTIATION's class (`Box%0`), registered on demand — the Lowerer
         // hook owns the instance table (monomorphization by flow).
         if (classDecl.typeParameters) {
-            return ctx.genericClassInstance ? ctx.genericClassInstance(classDecl, widened) : null;
+            const instance = ctx.genericClassInstance
+                ? ctx.genericClassInstance(classDecl, widened)
+                : null;
+            // Before the generic declaration's collection turn, the hook can only
+            // return its family shell; after collection the same checker type names
+            // a concrete registered instance. Never memoize either phase's answer.
+            if (instance !== null)
+                contextResolutions++;
+            return instance;
         }
         return { kind: "object", className: classNamer(classDecl) };
     }
@@ -2541,7 +2675,12 @@ function mapGenericUtilityAlias(widened, ctx) {
     }
     // Fields inherit the source shape's canonical (name-sorted) order — and
     // its declaration order (mapped types preserve property order in TS).
-    return { kind: "record", shapeId: shapes.intern(fields, false, undefined, shape.declaredOrder) };
+    const originalOrder = shape.declaredOrder;
+    const shapeId = shapes.intern(fields, false, undefined, originalOrder);
+    if (originalOrder !== undefined) {
+        shapes.inheritDeclaredOrder(shapeId, originalOrder, bound.shapeId);
+    }
+    return { kind: "record", shapeId };
 }
 /** The UNIT-ONLY slot type: the interned `null | undefined` union, the one
  * representation the IR already has for values that are nothing but units.