@scriptc/compiler 0.4.2 → 0.4.3

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

@@ -32,6 +32,9 @@ export declare class ClassDynamicDispatch {
     private deletedNames;
     private readonly boxed;
     private readonly boxedConstructors;
+    /** Every class a boxed value was statically typed as, runtime error
+     * classes included: the value's capsule can be any of its subclasses. */
+    private readonly boxedStatic;
     private readonly dispatches;
     private readonly properties;
     private readonly computed;
@@ -63,8 +66,17 @@ export declare class ClassDynamicDispatch {
     private descriptorHelper;
     private prototypeHelper;
     private readonly prototypeClasses;
-    private prototypeIdentityHelper;
-    private readonly prototypeIdentityClasses;
+    /** The stand-in prototype object of each class without prototype data
+     * (prototypeStandIn), by class name. */
+    private readonly prototypeStandIns;
+    /** The prototype reads of identity walks, by libCall, and the classes
+     * each one answers for boxed instances. */
+    private readonly prototypeIdentityHelpers;
+    /** `value instanceof Error` through Error.prototype: boxed instances of
+     * classes with a heritage evaluated at run time test their prototype
+     * data's chain. */
+    private errorPrototypeHelper;
+    private readonly errorPrototypeClasses;
     private readonly instancePrototypes;
     private readonly checkedCasts;
     /** The for-in key helpers, by libCall (dyn and native string[] keys). */
@@ -80,6 +92,9 @@ export declare class ClassDynamicDispatch {
     process(lowerer: Lowerer, functions: readonly IrFunction[]): boolean;
     /** The receiver's own dynamic properties for a read: undefined while it has
      * none, and never stored, so reads stay valid on published objects. */
+    /** Statements that return `className`'s stand-in prototype: one empty
+     * object per class, created on first use and kept in a module global. */
+    private prototypeStandIn;
     private readPropertyBag;
     /** The bag a read looks a key up in (`%dyn.class.readPropertiesOrEmpty`):
      * the receiver's own properties, or a fresh empty object (not stored) while
@@ -152,6 +167,11 @@ export declare class ClassDynamicDispatch {
      * A class with constructible subclasses that have prototype data selects
      * it through its `%class.bagPrototype` helper; any other class reads its
      * own prototype data. */
+    /** The lazy bag stores as they stand in the generated bodies, by class.
+     * Worklist passes that transform every function rebuild statement
+     * objects, so a recorded initializer can be a detached copy; a store that
+     * gains its prototype must be updated where it runs. */
+    private liveBagInitializers;
     private bagPrototype;
     /** `%class.bagPrototype:<class>(this)`: the prototype data of the most
      * derived constructible class `this` is an instance of, tested from the
@@ -169,6 +189,23 @@ export declare class ClassDynamicDispatch {
      * prototype-backed bag is produced for this read only. A published object
      * cannot take the store, and Node's reads never write. */
     finalize(lowerer?: Lowerer): void;
+    /** Each tracked class's bag initializer over a typed receiver (`this`),
+     * for the per-class field-creation helpers (trackClassFieldCreation),
+     * which create an instance's bag without the class-table dispatch. */
+    private recordBagInitializers;
+    /** Fast exits for the generated class tables: every class branch of
+     * the property-bag, normalization and static-bag helpers tests the
+     * value's capsule key (or class key), so a value of another kind (a
+     * plain object, the common case in untyped code) skips straight to the
+     * table's fallthrough instead of testing every class in the program. */
+    private guardClassTables;
+    /** Fast exits for the generated property helpers: when every class
+     * branch tests a capsule key or a class key and the fallthrough is still
+     * the bag access the helper was created with, a value of another kind
+     * (a plain object, array or primitive) normalizes to itself, has itself
+     * as its bag, and so gets the plain access directly, without the
+     * normalization, bag and static-bag calls. */
+    private guardPropertyHelpers;
     private normalizedDispatches;
     private constructorPropertyBag;
     /** A base capsule and a derived capsule refer to the same native object.