@scriptc/compiler 0.4.5 → 0.4.6

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

@@ -150,6 +150,12 @@ export interface ClassInfo {
      * constructor's rules, and the Date methods it does not declare lower
      * over that value. Subclasses inherit the field. */
     extendsDate?: true;
+    /** A class declared `extends Array` (builtins/array-classes.ts): its
+     * instances are arrays of `elem` whose own fields follow the array
+     * header, and its TypeScript type maps to `elem[]`. */
+    extendsArray?: {
+        elem: IrType;
+    };
     /** The synthetic LifetimeRegion class (@scriptc/experimental,
      * lifetime-regions.ts): its constructor is synthesized with the class,
      * and its methods lower at their call sites. */

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

@@ -1,6 +1,8 @@
 import { lowerAsyncLocalStorageOptions } from "./builtins/async-context.js";
+import { shapeOverlayAnnotated } from "../shape-inference/index.js";
 import { DATE_TIME_FIELD, dateRootOf, dateSuperCall, isDatePrototypeMethod, lowerDateSuperMethodCall, } from "./builtins/date-classes.js";
 import { predeclareForwardClass } from "./lower-stmts.js";
+import { arrayClassBase, arrayClassFieldsFn, arrayClassSpeciesFn, arraySuperCall, refuseArrayClassSpecies, lowerArraySuperCall, } from "./builtins/array-classes.js";
 import { lowerDateStaticCall } from "./builtins/dates.js";
 import { keyedHelperName } from "./stable-names.js";
 import { lowerValueReturningConstructorNew } from "./js-dynamic-objects.js";
@@ -37,11 +39,15 @@ import { omittedArgFor } from "./call-arguments.js";
 import { checkerTypeDescription, isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm, X509_DER_FIELD, X509_PUBLIC_KEY_FIELD, } from "../type-mapper.js";
 import { canonicalBuiltinModule, cjsClassExprWholeExportOf, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, locOf, requireSpecOf, } from "../program.js";
 import { PoisonError, dynFallbackType, jsFuncNameOf, newFnCtx, own } from "./lowerer.js";
+import { islandValueOrigin } from "../node-api-import.js";
+import { nativeSubclassOfIslandDiag } from "../../diagnostics/diagnostic.js";
+import { isForeignType, isIslandSubclassDecl } from "../../node-islands/boundary.js";
+import { declarationGroupKey } from "./type-failure.js";
 import { isAssertClassNew } from "./assert-instances.js";
 import { isCjsRequireGlobal } from "./lower-node-module.js";
 import { lowerArrayConstructor } from "./containers/array-construction.js";
 import { initializedCollectionType } from "./js-collection-types.js";
-import { lowerMapSeedNew, lowerSetSeedNew } from "./containers/collection-methods.js";
+import { lowerMapSeedNew, lowerSetSeedNew, mapFromSeedValue, } from "./containers/collection-methods.js";
 import { lowerObjectConstructor } from "./containers/indexed-objects.js";
 import { knownBufEncoding, lowerBufferConstruct } from "./containers/bytes.js";
 import { lowerSearchParamsNew } from "./builtins/url.js";
@@ -52,7 +58,7 @@ import { STREAM_API_MEMBERS, STREAM_PROP_MEMBERS, STREAM_COMPLETION_CALLBACK_IND
 import { builtinEventTargetBaseOf, eventTargetApiMembers, eventTargetApiMethod, eventTargetRootOf, eventTargetSuperCall, lowerEventTargetMethodCall, } from "./lower-event-target.js";
 import { emitOverrideShapeReason, emitSpecSuperForward, emitterRooted, lowerEmitterSuperCall, } from "./lower-event-emitter.js";
 import { declSymbolOf } from "./lower-modules.js";
-import { classSymbolKeyOf, classSymbolKeyOfSymbol, symbolFieldDisplayName, } from "./symbol-fields.js";
+import { INSPECT_CUSTOM_MEMBER, classSymbolKeyOf, classSymbolKeyOfSymbol, symbolFieldDisplayName, } from "./symbol-fields.js";
 import { lowerHttpAgentNew, lowerHttpServerNew, lowerTlsSocketNew } from "./lower-server.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, contextualUndefReadType, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead, } from "./lower-namespaces.js";
 import { mixinResultBindingClassOf } from "./lower-mixins.js";
@@ -667,7 +673,11 @@ function jsFieldInitializerType(lowerer, type, expression) {
                     (lowerer.typeOf(expression).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0)))
             return DYN;
     }
-    if (type.kind === "array" || type.kind === "record")
+    // Shape inference's overlay types a field as a record or array only when
+    // the analysis proves its values never reach code that could observe a
+    // copy, so those fields keep their native layout.
+    if ((type.kind === "array" || type.kind === "record") &&
+        !shapeOverlayAnnotated(expression.parent?.parent ?? expression))
         return DYN;
     // JavaScript documentation cannot guarantee that a call or an indexed
     // read returns a present number. Numeric fields receiving those values
@@ -1079,6 +1089,9 @@ export function guaranteedDecorationThrow(lowerer, decl) {
     return null;
 }
 export function collectClassShape(lowerer, decl) {
+    // A native class extending an island class has no native shape (NI-5b).
+    if (isIslandSubclassDecl(decl))
+        return;
     if (lowerer.classes.has(lowerer.classNamer(decl)) ||
         lowerer.collectingClassDeclarations.has(decl))
         return;
@@ -1369,6 +1382,7 @@ mixin) {
         let genericBase;
         let callableBase;
         let extendsDate = false;
+        let extendsArray;
         let factoryBaseExpression;
         const adoptCallableBase = (expression) => {
             if (familyMode || inst || mixin)
@@ -1544,11 +1558,25 @@ mixin) {
                     continue;
                 }
             }
+            if (t &&
+                (islandValueOrigin(lowerer.program, t.expression) ||
+                    (lowerer.nodeIslands !== null &&
+                        isForeignType(lowerer.nodeIslands, lowerer.typeOf(t.expression), lowerer.checker)))) {
+                lowerer.pushDiag(nativeSubclassOfIslandDiag(locOf(t)));
+                throw new PoisonError();
+            }
             if (!t || !ts.isIdentifier(t.expression)) {
                 if (t && adoptCallableBase(t.expression))
                     continue;
                 lowerer.unsupported("SC1090", clause, "extending computed expressions");
             }
+            if ((familyMode || inst) && lowerer.isStdlibGlobal(t.expression, "Array"))
+                lowerer.unsupported("SC1090", t, "a generic class that extends Array");
+            if (!familyMode && !inst && !mixin && lowerer.isStdlibGlobal(t.expression, "Array")) {
+                extendsArray = arrayClassBase(lowerer, t);
+                refuseArrayClassSpecies(lowerer, decl);
+                continue;
+            }
             if (!familyMode && !inst && !mixin && lowerer.isStdlibGlobal(t.expression, "Date")) {
                 if (t.typeArguments?.nodes)
                     lowerer.unsupported("SC1090", t, "extending generic classes");
@@ -1626,11 +1654,24 @@ mixin) {
             }
             if (t.typeArguments?.nodes)
                 lowerer.unsupported("SC1090", t, "extending generic classes");
+            if (named?.extendsArray)
+                lowerer.unsupported("SC1090", t, `extending '${t.expression.text}', a class that extends Array (one level of Array subclass compiles)`);
             base = named;
             if (!base) {
                 if (adoptCallableBase(t.expression))
                     continue;
-                lowerer.unsupported("SC1090", t, `extending classes not declared in the program ('${t.expression.text}')`);
+                // A base whose own collection deferred can still register later
+                // (a flush retry with dynamic slots): the derived class retries
+                // with it (Lowerer.retryDeferred).
+                const diag = unsupportedDiag("SC1090", locOf(t), `extending classes not declared in the program ('${t.expression.text}')`);
+                lowerer.retriableDiags.add(diag);
+                // A base the program declares but rejected: this rejection is its
+                // cascade (localized failure, report-only).
+                const rejectedBase = rejectedProgramClassGroup(lowerer, symbol);
+                if (rejectedBase !== null)
+                    diag.cause = [rejectedBase];
+                lowerer.pushDiag(diag);
+                throw new PoisonError();
             }
         }
         if (base?.localClass && !functionLocalClass(decl) && !computedBase && !factoryBaseExpression) {
@@ -1831,11 +1872,12 @@ mixin) {
                     if (type.kind === "void")
                         lowerer.badType(member.name, lowerer.typeOf(member.name));
                     if (type.kind === "dyn" &&
+                        !lowerer.liftDynFieldPolicy &&
                         !isJsSourceFile(ts.getSourceFileOfNode(member)) &&
                         !lowerer.classFieldStoresDyn(lowerer.typeOf(member.name)) &&
                         (member.type !== undefined ||
                             (lowerer.typeOf(member.name).flags & ts.TypeFlags.Any) === 0)) {
-                        lowerer.unsupported("SC1090", member.name, `${dynFieldTypeSpelling(lowerer, member.name)}-typed static fields`);
+                        lowerer.dynFieldPolicyFence(member.name, `${dynFieldTypeSpelling(lowerer, member.name)}-typed static fields`);
                     }
                     staticFields.push({
                         name: member.name.text,
@@ -2251,11 +2293,14 @@ mixin) {
                     lowerer.badType(member.name, lowerer.typeOf(member.name));
                 // Bundled JS declares fields without annotations before assigning
                 // them in the constructor. Use the same native checked-dynamic
-                // storage as implicit constructor-assigned JS fields.
+                // storage as implicit constructor-assigned JS fields. In
+                // TypeScript the refusal is a policy fence that a flush retry lifts
+                // (Lowerer.liftDynFieldPolicy).
                 if (type.kind === "dyn" &&
+                    !lowerer.liftDynFieldPolicy &&
                     !isJsSourceFile(ts.getSourceFileOfNode(member)) &&
                     !lowerer.classFieldStoresDyn(lowerer.typeOf(member.name))) {
-                    lowerer.unsupported("SC1090", member.name, `${dynFieldTypeSpelling(lowerer, member.name)}-typed class fields`);
+                    lowerer.dynFieldPolicyFence(member.name, `${dynFieldTypeSpelling(lowerer, member.name)}-typed class fields`);
                 }
                 const undefinedInitializer = type.kind === "dyn" && !member.initializer ? locOf(member) : undefined;
                 if (fields.has(member.name.text)) {
@@ -2381,8 +2426,10 @@ mixin) {
                     if (type.kind === "void")
                         lowerer.badType(p.name, lowerer.typeOf(p.name));
                     // The class-field dyn rule verbatim (KEEP NARROW).
-                    if (type.kind === "dyn" && !lowerer.classFieldStoresDyn(lowerer.typeOf(p))) {
-                        lowerer.unsupported("SC1090", p.name, `${dynFieldTypeSpelling(lowerer, p)}-typed class fields`);
+                    if (type.kind === "dyn" &&
+                        !lowerer.liftDynFieldPolicy &&
+                        !lowerer.classFieldStoresDyn(lowerer.typeOf(p))) {
+                        lowerer.dynFieldPolicyFence(p.name, `${dynFieldTypeSpelling(lowerer, p)}-typed class fields`);
                     }
                     // `override x` (and any same-named inherited member) would
                     // redeclare a base slot — the declared-field rule verbatim.
@@ -2486,6 +2533,7 @@ mixin) {
                     !functionLocalClass(decl) &&
                     ts.isIdentifier(member.name) &&
                     !lowerer.virtualJsMethods.has(member) &&
+                    !lowerer.checkedJsOverrideMethods.has(member) &&
                     !lowerer.prototypeMethodAccesses.has(member.name.text) &&
                     inst === undefined &&
                     decl.typeParameters === undefined &&
@@ -2537,7 +2585,15 @@ mixin) {
                             shape.bodyType = DYN;
                     }
                     ft.params = shapes.map((shape) => shape.type);
-                    if (ft.ret.kind !== "void")
+                    // A GENERATOR method's result is the suspended generator its spawn
+                    // wrapper answers, so the generator kind IS the checked-crossable
+                    // ABI: dynFrom boxes a generator by reference and dyn calls resume
+                    // it through the dyn generator ops. Replacing it with plain DYN
+                    // would leave the method no representation at all (the generator
+                    // branch below needs the channels to build its metadata), which
+                    // fenced every `c.m` read on a prototype-accessed class. Only the
+                    // ARGUMENTS cross as checked values here.
+                    if (ft.ret.kind !== "void" && member.asteriskToken === undefined)
                         ft.ret = DYN;
                 }
                 // JS subclasses can add parameters to a method. Reserve checked
@@ -3413,7 +3469,7 @@ mixin) {
         const ctorParams = ctor && !mixinForwarding
             ? lowerer.paramShapes(ctor.parameters.nodes)
             : (base?.ctorParams ??
-                (callableBase || extendsDate ? [{ type: DYN, mode: "dynRest" }] : []));
+                (callableBase || extendsDate || extendsArray ? [{ type: DYN, mode: "dynRest" }] : []));
         if (ctor &&
             !mixinForwarding &&
             isJsSourceFile(ts.getSourceFileOfNode(ctor)) &&
@@ -3454,6 +3510,10 @@ mixin) {
                 ...(methods.size > 0 ? { methods: [...methods.keys()] } : {}),
                 ...(() => {
                     const names = classPrototypeNames(decl);
+                    // A [util.inspect.custom] method, by its reserved slot name: the
+                    // checked-dynamic inspect walk refuses instances that have one.
+                    if (methods.has(INSPECT_CUSTOM_MEMBER))
+                        names.push(INSPECT_CUSTOM_MEMBER);
                     return names.length > 0 ? { prototypeNames: names } : {};
                 })(),
                 ...(abstractClass ? { abstract: true } : {}),
@@ -3462,6 +3522,13 @@ mixin) {
                     return am.length > 0 ? { abstractMethods: am } : {};
                 })(),
                 ...(inst ? { genericOf: inst.family.def.name } : {}),
+                ...(extendsArray
+                    ? {
+                        arrayElem: extendsArray.elem,
+                        arrayFields: `%${className}.arrayFields`,
+                        arraySpecies: `%${className}.species`,
+                    }
+                    : {}),
                 loc: locOf(decl),
             },
             fields,
@@ -3478,6 +3545,7 @@ mixin) {
             ...(genericBase ? { genericBase } : {}),
             ...(callableBase ? { callableBase } : {}),
             ...(extendsDate ? { extendsDate: true } : {}),
+            ...(extendsArray ? { extendsArray } : {}),
             ...(factoryBaseExpression ? { factoryBaseExpression } : {}),
             subclasses: [],
             throwingSetters,
@@ -5034,6 +5102,7 @@ function lowerClassValue(lowerer, expr, info, binding) {
         const context = newFnCtx(true, null, null, VOID);
         info.localClass.context = context;
         lowerer.fnStack.push(context);
+        const diagsBefore = lowerer.diags.length;
         try {
             const bodies = lowerClassMembers(lowerer, info);
             for (const body of bodies)
@@ -5049,6 +5118,9 @@ function lowerClassValue(lowerer, expr, info, binding) {
                 });
             }
             info.localClass.ready = true;
+            // A retry of the enclosing statement reuses these bodies.
+            for (const d of lowerer.diags.slice(diagsBefore))
+                lowerer.loweredOnceDiags.add(d);
             lowerer.onExprClassCollected?.(info);
         }
         finally {
@@ -6292,6 +6364,14 @@ export function collectVirtualJsMethods(lowerer, files) {
                                 continue;
                             const property = lowerer.checker.getPropertyOfType(base, member.name.text);
                             for (const declaration of property ? property.declarations : []) {
+                                if (ts.isMethodDeclaration(declaration) &&
+                                    isJsSourceFile(ts.getSourceFileOfNode(declaration)) &&
+                                    checkedJsOverride(lowerer, declaration, member)) {
+                                    // A checked override pair dispatches through the vtable,
+                                    // so neither side may become an implicit generic.
+                                    lowerer.checkedJsOverrideMethods.add(declaration);
+                                    lowerer.checkedJsOverrideMethods.add(member);
+                                }
                                 if (ts.isMethodDeclaration(declaration) &&
                                     isJsSourceFile(ts.getSourceFileOfNode(declaration)) &&
                                     !checkedJsOverride(lowerer, declaration, member)) {
@@ -6357,7 +6437,7 @@ export function collectVirtualJsMethods(lowerer, files) {
  * against its base, so both keep their declared signatures, as in
  * TypeScript classes. */
 function checkedJsOverride(lowerer, base, member) {
-    return [base, member].every((method) => lowerer.checkedJsFile(ts.getSourceFileOfNode(method)) &&
+    return [base, member].every((method) => (lowerer.checkedJsFile(ts.getSourceFileOfNode(method)) || shapeOverlayAnnotated(method)) &&
         method.parameters.nodes.every(documentedParameter));
 }
 /** The receiver's EXACT runtime class, when the expression proves it: a
@@ -6588,6 +6668,14 @@ export function lowerClassMembers(lowerer, info) {
         const diagsBefore = lowerer.diags.length;
         try {
             out.push(lowerer.lowerClassCtor(info));
+            if (info.extendsArray) {
+                const fields = arrayClassFieldsFn(lowerer, info);
+                if (fields)
+                    out.push(fields);
+                const species = arrayClassSpeciesFn(lowerer, info);
+                if (species)
+                    out.push(species);
+            }
         }
         catch (e) {
             if (!(e instanceof PoisonError))
@@ -6644,6 +6732,10 @@ export function lowerClassMembers(lowerer, info) {
  * the base's signature — forward every param to super(), then run own
  * field initializers. */
 export function lowerClassCtor(lowerer, info) {
+    if (info.extendsArray) {
+        lowerer.noteEdge(`%${info.def.name}.arrayFields`);
+        lowerer.noteEdge(`%${info.def.name}.species`);
+    }
     const cached = info.localClass?.bodies.get(`%${info.def.name}.constructor`);
     if (cached)
         return cached;
@@ -6711,7 +6803,7 @@ function lowerClassCtorInner(lowerer, info) {
                 lowerer.ctx.argumentsLocal = local;
             }
             body.push(...declared.prologue);
-            if (!ctorBase && !info.callableBase && !info.extendsDate) {
+            if (!ctorBase && !info.callableBase && !info.extendsDate && !info.extendsArray) {
                 // Node's base-class order: field initializers run at the start
                 // of construction, the parameter-property assignments open the
                 // constructor body (probed — a field initializer reading a
@@ -6726,7 +6818,7 @@ function lowerClassCtorInner(lowerer, info) {
             }
         }
         else {
-            if (ctorBase || info.callableBase || info.extendsDate) {
+            if (ctorBase || info.callableBase || info.extendsDate || info.extendsArray) {
                 // Synthetic forwarding params (the inherited ABI signature).
                 // Nothing references them by symbol — only the super call below,
                 // which forwards the already-completed values UNCHANGED (defaults
@@ -7673,7 +7765,10 @@ export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
                 loc,
             },
         ];
-        if (info.callableBase || info.extendsDate) {
+        if (info.extendsArray) {
+            statements.push(...lowerArraySuperCall(lowerer, info, thisLocal, superCall));
+        }
+        else if (info.callableBase || info.extendsDate) {
             if (superCall.arguments.nodes.some(ts.isSpreadElement))
                 lowerer.unsupported("SC1090", superCall, info.extendsDate
                     ? "spreading super arguments into the Date constructor"
@@ -7822,6 +7917,8 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
     };
     if (info.extendsDate)
         return dateSuperCall(thisRef, info, args[0], loc);
+    if (info.extendsArray)
+        return arraySuperCall(info, thisRef, args[0], loc);
     if (info.callableBase)
         return {
             kind: "exprStmt",
@@ -9266,6 +9363,28 @@ export function lowerNew(lowerer, expr) {
                     mapped = ctxMapped;
                 }
             }
+            // `new Map(source)` the checker types `Map<any, any>` because the
+            // source's checker type joins an untyped `new Map()` with a typed map
+            // (a union of map types): the copy takes the layout the source value
+            // actually has.
+            if (seedArg &&
+                !entriesLit &&
+                mapped?.kind === "map" &&
+                mapped.key.kind === "dyn" &&
+                mapped.value.kind === "dyn" &&
+                (expr.typeArguments?.nodes.length ?? 0) === 0 &&
+                !isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+                lowerer.mapTypeOf(lowerer.typeOf(seedArg))?.kind === "union") {
+                const source = lowerer.lowerExpr(seedArg);
+                if (source.type.kind === "map" &&
+                    source.type.key.kind !== "dyn" &&
+                    source.type.value.kind !== "dyn") {
+                    const copied = mapFromSeedValue(lowerer, source, source.type);
+                    if (copied)
+                        return copied;
+                }
+                lowerer.noLowering("new Map(entries)", expr, "a source whose map layouts differ (give the empty `new Map()` its type arguments)");
+            }
             if (seedArg && !entriesLit && mapped?.kind === "map") {
                 const seeded = lowerMapSeedNew(lowerer, seedArg, mapped);
                 if (seeded)
@@ -9551,12 +9670,14 @@ export function lowerNew(lowerer, expr) {
                 propertyAssignedClassInfoOf(lowerer, lowerer.checker.getSymbolAtLocation(expr.expression.name));
                 info = lowerer.classes.get(calleeT.className);
             }
+            // The TYPE world names a class the lowering never registered — a
+            // fenced class expression, an abstract/deferred declaration: flush
+            // its own diagnostics (they tell the real story, unless the flush
+            // registers it with dynamic slots) and poison this construction
+            // site, never an ICE.
+            if (!info)
+                info = lowerer.flushDeferredClass(calleeT.className);
             if (!info) {
-                // The TYPE world names a class the lowering never registered —
-                // a fenced class expression, an abstract/deferred declaration:
-                // flush its own diagnostics (they tell the real story) and
-                // poison this construction site, never an ICE.
-                lowerer.flushDeferredClass(calleeT.className);
                 lowerer.unsupported("SC1090", expr, "constructing through a class value whose class has no lowering (the class declaration itself was rejected — see its own diagnostic)");
             }
             // A classval of a generic FAMILY (`new () => Box<any>` slots): no
@@ -10005,4 +10126,17 @@ function definedThroughReflection(lowerer, decl) {
     });
     return found;
 }
+/** The failure group of a class the program declares but did not collect
+ * (its own declaration was rejected), or null for any other symbol. */
+function rejectedProgramClassGroup(lowerer, symbol) {
+    if (symbol === null)
+        return null;
+    const recorded = lowerer.rejectedGroups.get(symbol);
+    if (recorded !== undefined)
+        return recorded;
+    const decl = symbol.declarations.find((d) => ts.isClassDeclaration(d) || ts.isClassExpression(d));
+    if (decl === undefined || ts.getSourceFileOfNode(decl).isDeclarationFile)
+        return null;
+    return declarationGroupKey(symbol);
+}
 //# sourceMappingURL=lower-classes.js.map