@scriptc/compiler 0.0.7 → 0.0.8

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

@@ -568,6 +568,19 @@ export declare function genericOverrideBelow(L: Lowerer, info: ClassInfo, name:
    * new D()` receiver is exactly D, not its annotation. Distinct from
    * exactClassOfReceiver, which answers for CLASS-VALUE receivers. */
 export declare function exactInstanceClassOf(L: Lowerer, expr: ts.Expression): ClassInfo | null;
+/** `const r: Repo = new MemRepo()` where EVERY member of the annotation's
+   * checker type is a generic-callable method (`interface Repo { get<T>(id:
+   * string): T }`): the record shape maps EMPTY — generic members are
+   * excluded (no closure slot can hold a generic function) — so the
+   * copy-reshape width coercion would DROP the exact class the method
+   * calls monomorphize against, and in JS the binding IS the instance (no
+   * copy exists). The binding keeps the initializer's class
+   * representation instead: generic-method calls resolve like class-typed
+   * receivers (exactInstanceClassOf reads the same const+new discipline),
+   * and uses that want the empty record width-coerce at the use site.
+   * Const + direct `new` only — a reassignable binding or a produced
+   * value keeps today's record story and its fences. */
+export declare function genericIfaceBindingKeepsClass(L: Lowerer, decl: ts.VariableDeclaration, declaredType: IrType): boolean;
 /** `recv.m<T>(args)` — a GENERIC method call, dispatched STATICALLY: the
    * checker's resolved signature (type arguments substituted, inferred or
    * explicit) keys one instantiation of the nearest declarer's body, and
@@ -579,7 +592,7 @@ export declare function exactInstanceClassOf(L: Lowerer, expr: ts.Expression): C
 export declare function lowerClassGenericMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recvInfo: ClassInfo, found: {
     declarer: ClassInfo;
     info: GenericFnInfo;
-}): IrExpr;
+}, recvIr?: IrExpr): IrExpr;
 /** Wraps a derived-class expression in an upcast when the target base
    * class differs (a no-op reinterpret at runtime; keeps IR types exact). */
 export declare function upcastTo(L: Lowerer, expr: IrExpr, className: string): IrExpr;

package/dist/frontend/lowering/lower-classes.js

@@ -2802,13 +2802,28 @@ export function lowerStaticMethodCall(L, call, access) {
         return null;
     return staticCallOn(L, call, access, info, throughValue);
 }
+/** True when a class-VALUE receiver can only hold `info`'s own class
+   * object at runtime: the receiver provably IS the class
+   * (exactClassOfReceiver — the name, or a const bound to the class
+   * expression / class name), or `info` is a LEAF class, so no strict
+   * descendant exists to flow into the slot (the static-write path's
+   * rule — a rebindable decorated name rides this arm, since replacement
+   * decorators fence any class with subclasses before minting the
+   * rebindable global). Exactly then a #private static access through
+   * the value always carries the declaring class's brand — Node's
+   * TypeError cannot arise. */
+function classValueIsExactlyOwn(L, recv, info) {
+    return exactClassOfReceiver(L, recv) === info || info.subclasses.length === 0;
+}
 function staticCallOn(L, call, access, info, throughValue) {
     const loc = locOf(call);
-    // #private statics: through-a-VALUE receivers fence (a classval slot
-    // can hold a descendant at runtime and only the declaring class
-    // object carries the brand in JS), and the direct spelling resolves
-    // only on the declaring class itself — `D.#s` is Node's TypeError.
-    if (access.name.text.startsWith("#") && throughValue) {
+    // #private statics: through-a-VALUE receiver the call devirtualizes
+    // exactly when the value can only BE the declaring class
+    // (classValueIsExactlyOwn — a slot that could hold a descendant at
+    // runtime fences, since only the declaring class object carries the
+    // brand in JS), and the direct spelling resolves only on the
+    // declaring class itself — `D.#s` is Node's TypeError.
+    if (access.name.text.startsWith("#") && throughValue && !classValueIsExactlyOwn(L, access.expression, info)) {
         L.unsupported("SC1090", call, `calling the private static '${access.name.text}' through a class value (JS brands the declaring class object alone — call it through the class's own name)`);
     }
     const found = findStaticOn(L, info, access.name.text);
@@ -2897,13 +2912,21 @@ export function lowerClassValueProperty(L, expr) {
     if (!found) {
         L.unsupported("SC1090", expr, `the static member '${member}' of class '${info.def.name.replace(/^%|^%m\d+\./, "")}' (static accessors and initializer-less static fields have no lowering, and Function members like .call/.bind/.prototype have no value form)`);
     }
-    // #private statics never read through class VALUES: the slot can hold
-    // a descendant at runtime and JS brands the declaring class object
-    // alone (Node's TypeError on any other receiver). The direct
-    // class-name spelling resolved in lowerStaticFieldRead, so a private
-    // reaching here is a classval-typed binding.
+    // #private statics read through a class VALUE exactly when the value
+    // can only BE the declaring class (classValueIsExactlyOwn — a const
+    // bound to the class expression / class name, or a leaf class): a
+    // slot that could hold a descendant at runtime fences, since JS
+    // brands the declaring class object alone (Node's TypeError on any
+    // other receiver). The direct class-name spelling resolved in
+    // lowerStaticFieldRead, so a private reaching here is a
+    // classval-typed binding.
     if (member.startsWith("#")) {
-        L.unsupported("SC1090", expr, `reading the private static '${member}' through a class value (JS brands the declaring class object alone — spell the declaring class's name)`);
+        if (!classValueIsExactlyOwn(L, expr.expression, info)) {
+            L.unsupported("SC1090", expr, `reading the private static '${member}' through a class value (JS brands the declaring class object alone — spell the declaring class's name)`);
+        }
+        if (found.declarer !== info) {
+            L.unsupported("SC1090", expr, `reading the private static '${member}' through the subclass '${info.def.name.replace(/^%|^%m\d+\./, "")}' (JS brands the declaring class object alone — Node throws a TypeError here; spell the declaring class's name)`);
+        }
     }
     if (staticShadowBelow(L, info, member)) {
         L.unsupported("SC1090", expr, `reading the static member '${member}' through a class value (a subclass of '${info.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it, so the runtime class decides which declaration answers)`);
@@ -3012,6 +3035,39 @@ export function exactInstanceClassOf(L, expr) {
         init = init.expression;
     return classOfNew(init);
 }
+/** `const r: Repo = new MemRepo()` where EVERY member of the annotation's
+   * checker type is a generic-callable method (`interface Repo { get<T>(id:
+   * string): T }`): the record shape maps EMPTY — generic members are
+   * excluded (no closure slot can hold a generic function) — so the
+   * copy-reshape width coercion would DROP the exact class the method
+   * calls monomorphize against, and in JS the binding IS the instance (no
+   * copy exists). The binding keeps the initializer's class
+   * representation instead: generic-method calls resolve like class-typed
+   * receivers (exactInstanceClassOf reads the same const+new discipline),
+   * and uses that want the empty record width-coerce at the use site.
+   * Const + direct `new` only — a reassignable binding or a produced
+   * value keeps today's record story and its fences. */
+export function genericIfaceBindingKeepsClass(L, decl, declaredType) {
+    if (declaredType.kind !== "record")
+        return false;
+    if (!ts.isIdentifier(decl.name) || decl.initializer === undefined || decl.type === undefined)
+        return false;
+    if ((ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) === 0)
+        return false;
+    let init = decl.initializer;
+    while (ts.isParenthesizedExpression(init))
+        init = init.expression;
+    if (!ts.isNewExpression(init))
+        return false;
+    const shape = L.shapes.get(declaredType.shapeId);
+    if (!shape || shape.fields.length > 0 || shape.indexValue !== undefined || shape.tuple === true)
+        return false;
+    const annT = L.typeOf(decl.name);
+    const props = L.checker.getPropertiesOfType(annT);
+    if (props.length === 0)
+        return false;
+    return props.every((p) => isGenericCallableMemberType(L.checker.getTypeOfSymbol(p), L.checker));
+}
 /** `recv.m<T>(args)` — a GENERIC method call, dispatched STATICALLY: the
    * checker's resolved signature (type arguments substituted, inferred or
    * explicit) keys one instantiation of the nearest declarer's body, and
@@ -3020,7 +3076,7 @@ export function exactInstanceClassOf(L, expr) {
    * runtime class could OVERRIDE the method (genericOverrideBelow) must be
    * statically exact (exactInstanceClassOf) — the override set then
    * resolves at compile time — or fences by name. */
-export function lowerClassGenericMethodCall(L, call, access, recvInfo, found) {
+export function lowerClassGenericMethodCall(L, call, access, recvInfo, found, recvIr) {
     const name = access.name.text;
     let { declarer, info } = found;
     if (genericOverrideBelow(L, recvInfo, name)) {
@@ -3038,7 +3094,7 @@ export function lowerClassGenericMethodCall(L, call, access, recvInfo, found) {
     const instance = info.implicitParams
         ? implicitCallInstance(L, call, info)
         : genericCallInstance(L, call, info);
-    const receiver = L.lowerExpr(access.expression);
+    const receiver = recvIr ?? L.lowerExpr(access.expression);
     const loc = locOf(call);
     // The declarer sits at/above the receiver's static class on the plain
     // path; the EXACT path can land below it (a base-typed const provably
@@ -4426,8 +4482,8 @@ export function lowerNew(L, expr) {
         // construct-and-set loop, pairs in array order, duplicates
         // overwrite). Other seeds — another Map, general iterables — keep
         // the fence: never silently an empty map. Unsupported key/value
-        // types get their half named specifically instead of the generic
-        // SC2001 (which fires for Map-typed slots elsewhere).
+        // types get their half named specifically instead of the component
+        // fence (SC2009, which names Map slots at value positions elsewhere).
         // `new Array<T>()` and the ELEMENTS forms (`new Array('hi', 'bye')`,
         // any argument list that is not one lone number) ARE array literals
         // — the spec's ArrayCreate + element writes. The one-NUMBER form
@@ -4514,6 +4570,20 @@ export function lowerNew(L, expr) {
                 return { kind: "mapNew", seed, type: mapped, loc };
             }
             const targs = L.checker.getTypeArguments(tsType);
+            // JAVASCRIPT `new Map()` whose arguments never resolved past
+            // Map<any, any> (no annotation, no contextual type, no seed): the
+            // WeakMap stance below — the VALUE lowers as an opaque DOM object
+            // (identity and truthiness are real), and every reached METHOD use
+            // meets its own per-site fence at runtime. The formatter's
+            // config-cache shape: module init constructs the caches
+            // unconditionally; the format path never touches them. TypeScript
+            // keeps the compile fence.
+            if (isJsSourceFile(expr.getSourceFile()) &&
+                (expr.arguments?.length ?? 0) === 0 &&
+                targs.length > 0 &&
+                targs.every((t) => (t.flags & ts.TypeFlags.Any) !== 0)) {
+                return { kind: "dynObjLit", type: DYN, loc };
+            }
             const keyIr = targs[0] ? L.mapTypeOf(targs[0]) : null;
             if (targs[0] && (!keyIr || !isSupportedMapKey(keyIr))) {
                 L.unsupported("SC1090", expr, `Map keys of type '${L.checker.typeToString(targs[0])}' ` +