@scriptc/compiler 0.2.0 → 0.2.2

package/dist/frontend/lowering/lower-classes.d.ts

@@ -6,7 +6,7 @@ import { type ScrDiagnostic } from "../../diagnostics/diagnostic.js";
 import { type EmitOverrideRec } from "./lower-event-emitter.js";
 import { type MixinInstanceInfo } from "./lower-mixins.js";
 export declare function returnsOnlyThis(member: ts.MethodDeclaration): boolean;
-export declare function storedClassValueType(lowerer: Lowerer, expression: ts.Expression): IrType | null;
+export declare function storedClassValueType(lowerer: Lowerer, expression: ts.Expression, visiting?: Set<import("../ts7/ast-node.js").AstNode>): IrType | null;
 export interface ClassMethodSignature {
     params: ParamShape[];
     ret: IrType;
@@ -16,7 +16,14 @@ export interface ClassMethodSignature {
 }
 export interface ClassInfo {
     def: IrClassDef;
+    expressionInitializationEmitted?: true;
+    runtimeStatics?: readonly ts.ClassElement[];
+    runtimePrototypeMembers?: readonly ts.ClassElement[];
     localPrototypeData?: true;
+    prototypeMethodValues?: Map<string, IrExpr>;
+    prototypeReflectionReady?: true;
+    prototypeObservedMethodsReady?: true;
+    prototypeReflectionRefusal?: string;
     localClass?: {
         context: FnCtx | null;
         bodies: Map<string, IrFunction>;
@@ -40,6 +47,7 @@ export interface ClassInfo {
         /** Redeclared field: initialize the existing slot at this position;
          * no new slot (def.fields excludes it). */
         redeclared?: true;
+        errorCause?: true;
     }[];
     /** OWN declared methods only — inherited lookups walk the base chain
      * (findMethodOn). An `abstract` entry is a signature with no body (and
@@ -129,6 +137,7 @@ export interface ClassInfo {
         constructorId: string;
         prototypeId: string;
     };
+    factoryBaseExpression?: ts.Expression;
     /** DIRECT subclasses, filled as derived classes collect — the frontend's
      * side of whole-program devirtualization (overrideBelow). */
     subclasses: ClassInfo[];
@@ -170,6 +179,7 @@ export interface ClassInfo {
         member: ts.MethodDeclaration;
         receiverInfo?: GenericFnInfo;
     }>;
+    staticMethodValues?: Map<string, IrExpr>;
     /** `static { ... }` blocks, in declaration order. They are DECLARATION-TIME
      * CODE, not shape: JS runs each block once when the class statement
      * evaluates, whether or not anything ever references the class — so their
@@ -568,6 +578,9 @@ export declare function findGenericMethodOn(lowerer: Lowerer, info: ClassInfo |
    * slot, so a call that could reach an override compiles only when the
    * receiver's runtime class is statically exact. */
 export declare function genericOverrideBelow(lowerer: Lowerer, info: ClassInfo, name: string): boolean;
+/** Discover inherited data writes before any base storage ABI is chosen.
+ * The checker does not widen a base field for assignments in JS subclasses. */
+export declare function collectInheritedJsFieldWrites(lowerer: Lowerer, files: readonly ts.SourceFile[]): void;
 /** Discover overrides before choosing inferred method ABIs. Class collection
  * visits bases first, including imported bases and class expressions, so the
  * collected subclass graph cannot answer this question yet. The checker
@@ -694,18 +707,10 @@ export declare function throwingSetterFn(lowerer: Lowerer, info: ClassInfo, prop
    * order) — a base constructor's prologue, a derived constructor's
    * super()-return continuation. */
 export declare function fieldInitStmts(lowerer: Lowerer, info: ClassInfo, thisLocal: IrLocal): IrStmt[];
-/** A derived constructor's body: statements lower as usual EXCEPT the
-   * top-level `super(...)` statement, which becomes a direct call to the
-   * base constructor over the same `this`, immediately followed by this
-   * class's field initializers (JS runs them when super returns). tsc
-   * guarantees a super call exists and runs before any this-use; the
-   * supported form is a top-level expression statement — anywhere else
-   * (conditionals, expression positions) is rejected, not misordered. */
-export declare function lowerDerivedCtorBody(lowerer: Lowerer, info: ClassInfo, thisLocal: IrLocal, 
-/** Mixin forwarding-constructor mode: `super(...args)` forwards these
- * pre-declared synthetic params directly (the spread never lowers —
- * the base's ABI is this constructor's ABI). */
-forward?: IrExpr[]): IrStmt[];
+/** Super statements initialize the base and then the derived fields on
+   * whichever control-flow path executes. Repeated calls are explicitly
+   * refused until native layouts can allocate a second receiver. */
+export declare function lowerDerivedCtorBody(lowerer: Lowerer, info: ClassInfo, thisLocal: IrLocal, forward?: IrExpr[]): IrStmt[];
 /** `super(args)` → direct call of the base constructor with the SAME
    * `this` (upcast; retained by the varRef read — the callee owns and
    * releases its param per the universal convention). */