@scriptc/compiler 0.2.1 → 0.2.2

package/dist/frontend/lowering/class-dynamic-dispatch.d.ts

@@ -3,6 +3,13 @@ import { type Lowerer } from "./lowerer.js";
 import { type ClassInfo } from "./lower-classes.js";
 export declare function classInstanceOf(lowerer: Lowerer, value: IrExpr, info: ClassInfo, loc: SrcLoc, classValue?: IrExpr): IrExpr;
 export declare function classPropertiesHelper(lowerer: Lowerer, loc: SrcLoc): IrFunction;
+/** A for-in presence recheck needs only the live property table, avoiding
+ * value conversion or a dispatch branch for every possible member name. */
+export declare function classForInHasKey(lowerer: Lowerer, value: IrExpr, key: IrExpr, loc: SrcLoc): IrExpr;
+/** Record field creation after the dispatch worklist closes, including writes
+ * in generated member tables. Native values stay in their slots; the bag
+ * owns only their property presence, attributes, and insertion position. */
+export declare function trackClassFieldCreation(lowerer: Lowerer, functions: IrFunction[]): void;
 /** Calls on native class capsules keep the instance's compiled methods. The
  * reachable-body fixed point discovers both the boxed classes and method
  * names before generating checked native dispatch; ordinary dyn receivers
@@ -17,6 +24,11 @@ export declare class ClassDynamicDispatch {
     private readonly dispatches;
     private readonly properties;
     private readonly computed;
+    private readonly computedClassHelpers;
+    private normalization;
+    private normalizationKey;
+    private staticPropertyBag;
+    private readonly staticBagClasses;
     private propertyBag;
     private readonly errorStrings;
     private readonly bagClasses;
@@ -28,15 +40,27 @@ export declare class ClassDynamicDispatch {
     private readonly constructed;
     private readonly instanceTests;
     private readonly jsonPrototypes;
+    private serializesClasses;
     private descriptorHelper;
     private prototypeHelper;
     private readonly prototypeClasses;
+    private prototypeIdentityHelper;
+    private readonly prototypeIdentityClasses;
     private readonly instancePrototypes;
+    private readonly checkedCasts;
+    private enumeration;
+    private readonly enumerationClasses;
     process(lowerer: Lowerer, functions: readonly IrFunction[]): boolean;
     /** A known native class can access its shared bag directly. Keep the
      * receiver as an owned parameter so calls and temporary instances retain
      * their ordinary evaluation and lifetime rules without a boxed capsule. */
     private typedPropertyBag;
+    private normalizedDispatches;
+    private constructorPropertyBag;
+    /** A base capsule and a derived capsule refer to the same native object.
+     * Select its actual layout once, so each member table needs one branch
+     * per class rather than one per possible base/derived capsule pair. */
+    private normalizeDispatches;
     /** The hidden bag is part of the native object layout, so every capsule
      * shares it and normal class tracing/disposal owns its values. Insert it
      * at the same prefix offset throughout a hierarchy, including classes
@@ -46,6 +70,7 @@ export declare class ClassDynamicDispatch {
      * Preorder insertion lets later branches test the most derived layout first. */
     private propertyReceivers;
     private propertyReceiver;
+    private reflectPropertyBody;
     private propertyBody;
     private methodBody;
 }