@scriptc/compiler 0.4.1 → 0.4.3

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

@@ -13,6 +13,7 @@ export declare function returnsOnlyThis(member: ts.MethodDeclaration): boolean;
  * claim setters). Used only to narrow a call's result back to the
  * receiver's class. */
 export declare function returnsOnlyThisValue(member: ts.MethodDeclaration): boolean;
+export declare function functionLocalClass(decl: ts.ClassLikeDeclaration): boolean;
 export declare function storedClassValueType(lowerer: Lowerer, expression: ts.Expression, visiting?: Set<import("../ts7/ast-node.js").AstNode>): IrType | null;
 export interface ClassMethodSignature {
     params: ParamShape[];
@@ -33,6 +34,10 @@ export interface ClassInfo {
     prototypeMethodValues?: Map<string, IrExpr>;
     prototypeReflectionReady?: true;
     prototypeObservedMethodsReady?: true;
+    /** The globals holding each observed method's original prototype value
+     * (set when the prototype data is built), by method name. A typed call
+     * whose slot still holds that value calls the method natively. */
+    prototypeOriginals?: Map<string, string>;
     prototypeReflectionRefusal?: string;
     localClass?: {
         context: FnCtx | null;
@@ -136,6 +141,11 @@ export interface ClassInfo {
      * lower-event-target.ts over any class rooted here. Subclass structs
      * embed the runtime prefix. */
     builtinEventTarget?: "target" | "event";
+    /** A class declared `extends Date` (builtins/date-classes.ts): its first
+     * field is the hidden `%time` value, super() sets it with the Date
+     * constructor's rules, and the Date methods it does not declare lower
+     * over that value. Subclasses inherit the field. */
+    extendsDate?: true;
     /** The synthetic LifetimeRegion class (@scriptc/experimental,
      * lifetime-regions.ts): its constructor is synthesized with the class,
      * and its methods lower at their call sites. */
@@ -265,6 +275,9 @@ export interface ClassInfo {
         path: InstantiationPath;
         family: ClassInfo;
         bindings: Map<ts.Symbol, IrType>;
+        /** The type arguments as checker types, for the resolutions that need
+         * literal identity (a conditional type over a literal argument). */
+        tsBindings: Map<ts.Symbol, ts.Type>;
         typeArgsText: string;
         ordinal: number;
     };
@@ -354,6 +367,9 @@ export interface GenericClassInfo {
         info: ClassInfo | null;
         poisoned?: boolean;
     }>;
+    /** The type parameters a conditional type in the class depends on
+     * (literalSensitiveTypeParams), computed on first instantiation. */
+    literalSensitive?: Set<ts.Symbol>;
 }
 /** The builtin Error hierarchy
  * as eagerly-registered ClassInfos: mapType names them the moment a lib
@@ -438,6 +454,7 @@ export declare function collectClassShapeInner(lowerer: Lowerer, decl: ts.ClassL
     family: ClassInfo;
     name: string;
     bindings: Map<ts.Symbol, IrType>;
+    tsBindings: Map<ts.Symbol, ts.Type>;
     typeArgsText: string;
     ordinal: number;
 }, 
@@ -570,8 +587,12 @@ export declare function lowerClassExpressionInfo(lowerer: Lowerer, expr: ts.Clas
  * mints a class at all: evaluating the expression IS the
  * ReferenceError, so it lowers to exactly that read — every evaluation
  * throws identically, which is why the once-evaluated restriction and
- * the member fences don't apply. */
-export declare function lowerClassExpression(lowerer: Lowerer, expr: ts.ClassLikeDeclaration): IrExpr;
+ * the member fences don't apply.
+ *
+ * `binding` is the local of a function-local class declaration's name,
+ * declared without a value; the class value assigns it before the class's
+ * static members are defined (see initializeRuntimeStatics). */
+export declare function lowerClassExpression(lowerer: Lowerer, expr: ts.ClassLikeDeclaration, binding?: IrLocal): IrExpr;
 /** The EXACT class a receiver expression is statically known to BE (not
  * merely be typed by): the class name itself, or a `const` binding
  * whose initializer is a class expression / class name. Such receivers
@@ -777,6 +798,12 @@ 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[];
+/** The comma chain of an `if` condition whose leading operands hold a
+ * super() call (`if (super(), r === 0) throw ...`, as minifiers join a
+ * super statement with the next test), or null. The if statement runs the
+ * chain's left operand as a statement first and tests its right operand,
+ * which is what the comma evaluates. */
+export declare function superConditionLead(cond: ts.Expression): ts.BinaryExpression | null;
 /** 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. */