@scriptc/compiler 0.2.6 → 0.2.8

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

@@ -89,6 +89,10 @@ export interface ClassInfo {
      * unassigned read throws the catchable TypeError instead of yielding
      * an undefined the declared type cannot hold (SEMANTICS.md). */
     deferredInitFields?: Set<string>;
+    /** True when construction may hand the instance to other code (a method
+     * call, an argument, a callback, or a base constructor that does) — a
+     * subclass's own fields can then be read before their assignment. */
+    constructionEscapes?: true;
     /** null for the builtin error classes (runtime-provided; no source).
      * Class EXPRESSIONS carry their ts.ClassExpression here — members,
      * accessors, and locs read identically off either form. */
@@ -164,6 +168,8 @@ export interface ClassInfo {
     staticFields: {
         name: string;
         type: IrType;
+        /** Indexed sources can be absent despite the declared static type. */
+        runtimeOptional?: true;
         initializer: ts.Expression;
         globalId: string;
         readonly: boolean;

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

@@ -1,4 +1,5 @@
 import { dynUndefinedExpr, nodeThrowExpr } from "../../ir/build.js";
+import { collectClassMethodMutations } from "./class-method-mutations.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Class lowering: shape collection over the single-inheritance graph
  * (fields, methods, accessors, overrides), constructor/member lowering with
@@ -41,6 +42,7 @@ import { lowerObjectFactoryNew } from "./object-factory-new.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { lowerInstanceConstructorNew } from "./class-instance-constructor.js";
 import { classPrototypeData } from "./class-prototypes.js";
+import { constructionEscape } from "./construction-escapes.js";
 import { checkedClassConstruction, checkedClassConstructionPacked } from "./class-construction.js";
 import { initializeRuntimeStatics, hasRuntimeStatics } from "./class-runtime-statics.js";
 import { reflectedClassStaticMethodValue } from "./class-method-values.js";
@@ -380,6 +382,10 @@ export function registerBuiltinErrorClasses(lowerer) {
                     { name: "%nameEnumerable", type: BOOL },
                     { name: "%stackFrames", type: STRING },
                     { name: "%stack", type: STRING },
+                    { name: "%systemErrno", type: F64 },
+                    { name: "%systemCall", type: STRING },
+                    { name: "%systemPath", type: STRING },
+                    { name: "%systemDest", type: STRING },
                 ],
                 loc,
             },
@@ -994,15 +1000,7 @@ function collectClassShapeDeferring(lowerer, decl) {
     const hasDeclTimeCode = (n) => ts.isClassStaticBlockDeclaration(n) ||
         (n.modifiers ?? []).some((m) => m.kind === ts.SyntaxKind.Decorator);
     if (symbol && (hasDeclTimeCode(decl) || decl.members.some(hasDeclTimeCode))) {
-        const diags = lowerer.deferredDiags.get(symbol);
-        if (diags) {
-            lowerer.deferredDiags.delete(symbol);
-            if (!lowerer.alreadyFlushed.has(symbol)) {
-                lowerer.flushedSymbols.add(symbol);
-                for (const d of diags)
-                    lowerer.pushDiag(d);
-            }
-        }
+        lowerer.reportDeferred(symbol);
     }
     // A poisoned BASE this class EXTENDS must report EAGERLY for the same
     // reason: the derived statement evaluates its heritage when module
@@ -1020,15 +1018,8 @@ function collectClassShapeDeferring(lowerer, decl) {
             ?.types.map((t) => t.expression)
             .filter(ts.isIdentifier)[0];
         const baseSym = baseIdent ? lowerer.resolveValueSymbol(baseIdent) : null;
-        const baseDiags = baseSym ? lowerer.deferredDiags.get(baseSym) : undefined;
-        if (baseSym && baseDiags) {
-            lowerer.deferredDiags.delete(baseSym);
-            if (!lowerer.alreadyFlushed.has(baseSym)) {
-                lowerer.flushedSymbols.add(baseSym);
-                for (const d of baseDiags)
-                    lowerer.pushDiag(d);
-            }
-        }
+        if (baseSym)
+            lowerer.reportDeferred(baseSym);
     }
 }
 function inferredEmptyCollectionFieldType(lowerer, decl, field, initializer) {
@@ -1691,7 +1682,7 @@ mixin) {
                         lowerer.badType(member.name, lowerer.typeOf(member.name));
                     if (type.kind === "dyn" &&
                         !isJsSourceFile(member.getSourceFile()) &&
-                        !lowerer.classImplementedProtocol(lowerer.typeOf(member.name)) &&
+                        !lowerer.classFieldStoresDyn(lowerer.typeOf(member.name)) &&
                         (member.type !== undefined ||
                             (lowerer.typeOf(member.name).flags & ts.TypeFlags.Any) === 0)) {
                         lowerer.unsupported("SC1090", member.name, "'unknown'-typed static fields");
@@ -1883,8 +1874,8 @@ mixin) {
                 // declaration is an ordinary OWN field (tsc guarantees every
                 // instantiable subclass declares it and, under
                 // strictPropertyInitialization, initializes it). Reads through
-                // ABSTRACT-typed receivers have no slot to read and keep a
-                // per-site fence.
+                // ABSTRACT-typed receivers resolve the concrete instance's
+                // property through checked class dispatch.
                 if (modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword))
                     continue;
                 if (modifiers?.some((m) => m.kind === ts.SyntaxKind.AccessorKeyword)) {
@@ -2054,7 +2045,7 @@ mixin) {
                 // storage as implicit constructor-assigned JS fields.
                 if (type.kind === "dyn" &&
                     !isJsSourceFile(member.getSourceFile()) &&
-                    !lowerer.classImplementedProtocol(lowerer.typeOf(member.name))) {
+                    !lowerer.classFieldStoresDyn(lowerer.typeOf(member.name))) {
                     lowerer.unsupported("SC1090", member.name, "'unknown'-typed class fields");
                 }
                 const undefinedInitializer = type.kind === "dyn" && !member.initializer ? locOf(member) : undefined;
@@ -2182,7 +2173,7 @@ 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.classImplementedProtocol(lowerer.typeOf(p))) {
+                    if (type.kind === "dyn" && !lowerer.classFieldStoresDyn(lowerer.typeOf(p))) {
                         lowerer.unsupported("SC1090", p.name, "'unknown'-typed class fields");
                     }
                     // `override x` (and any same-named inherited member) would
@@ -2234,15 +2225,12 @@ mixin) {
                     if (findGenericMethodOn(lowerer, base, mName)) {
                         lowerer.unsupported("SC1090", member.name, `overriding the inherited generic method '${mName}' with a non-generic method (generic methods dispatch statically and would never reach this override)`);
                     }
-                    // Abstract re-declarations keep the overridden ABI exactly,
-                    // like any override (a concrete implementation below must
-                    // agree with BOTH, which exactness makes one constraint).
                     const overridden = lowerer.findMethodOn(base, mName);
                     if (overridden &&
                         (overridden.sig.params.length !== shapes.length ||
                             !overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type)) ||
-                            !typeEquals(overridden.sig.ret, ret))) {
-                        lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter and return types must match the base declaration exactly)");
+                            !typeEquals(overridden.sig.ret, overrideReturnAbi(lowerer, ret, overridden.sig.ret, className, base)))) {
+                        lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter types must match the base declaration exactly; returns may narrow to a subclass)");
                     }
                     methods.set(mName, { params: shapes, ret, abstract: true });
                     continue;
@@ -2363,11 +2351,12 @@ mixin) {
                     if (refined)
                         ft.ret = refined;
                 }
-                // Overrides keep the EXACT overridden ABI signature. tsc's method
+                // Overrides keep the inherited ABI signature. tsc's method
                 // bivariance would let a narrowed parameter type through, and a
                 // vtable-dispatched call could then hand the override a base
                 // instance it reads out-of-bounds fields from — exactness keeps
-                // every slot sound (covariant returns can come later). Comparing
+                // every parameter slot sound. Nominal covariant returns share the
+                // base pointer ABI while retaining their declared result type. Comparing
                 // ABI types only (not modes) is deliberate: call sites complete
                 // against the STATIC receiver's shape, so `m(x?: number)` and
                 // `m(x: number | undefined)` interchange soundly in overrides.
@@ -2429,7 +2418,7 @@ mixin) {
                     member.asteriskToken === undefined &&
                     (overridden.sig.params.length !== shapes.length ||
                         !overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type)) ||
-                        !typeEquals(overridden.sig.ret, ft.ret))) {
+                        !typeEquals(overridden.sig.ret, overrideReturnAbi(lowerer, ft.ret, overridden.sig.ret, className, base)))) {
                     const fencedJsOverride = isJsSourceFile(member.getSourceFile()) &&
                         overridden.declarer.decl !== null &&
                         isJsSourceFile(overridden.declarer.decl.getSourceFile()) &&
@@ -2456,12 +2445,12 @@ mixin) {
                             });
                         methodEntryFences.set(mName, unsupportedDiag("SC1090", locOf(member.name), returnOnly
                             ? `overriding method '${mName}' with a different return type (the native return type must match the base declaration exactly)`
-                            : `overriding method '${mName}' with a different signature (the native parameter and return types must match the base declaration exactly)`));
+                            : `overriding method '${mName}' with a different signature (the native parameter types must match the base declaration exactly; returns may narrow to a subclass)`));
                         shapes.splice(0, shapes.length, ...overridden.sig.params);
                         ft.ret = overridden.sig.ret;
                     }
                     else {
-                        lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter and return types must match the base declaration exactly)");
+                        lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter types must match the base declaration exactly; returns may narrow to a subclass)");
                     }
                 }
                 const asyncMember = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
@@ -2622,6 +2611,52 @@ mixin) {
                 initializer: undefined,
             })));
         }
+        // Fields read before their first assignment. Construction that hands
+        // the instance to other code (a method call, an argument, a callback,
+        // a base constructor that does either) before assigning a class-typed
+        // field lets that code read the field while Node still holds
+        // undefined. Such fields take the deferred-init representation, whose
+        // slot (a nullable instance pointer) starts empty and whose reads check
+        // it. Fields assigned before any exposure keep their plain reads.
+        const derived = decl.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword) ??
+            false;
+        // Generic instances and mixins share layouts across declarations, so
+        // they only report whether construction exposes the instance.
+        const escape = familyMode || mixin
+            ? { escapes: derived, assigned: null }
+            : constructionEscape({
+                ctor,
+                fields: fieldOrder.flatMap((f) => paramProps.some((pp) => pp.name === f.name)
+                    ? []
+                    : [{ name: f.name, initializer: f.initializer }]),
+                paramProps: paramProps.map((pp) => pp.name),
+                derived,
+                baseEscapes: base === null ||
+                    callableBase !== undefined ||
+                    factoryBaseExpression !== undefined ||
+                    base.constructionEscapes === true,
+                isField: (name) => fields.has(name) &&
+                    !methods.has(`set:${name}`) &&
+                    !lowerer.findMethodOn(base, `set:${name}`),
+                privateMethodBody: (call) => {
+                    const callee = call.expression;
+                    if (!ts.isPropertyAccessExpression(callee))
+                        return null;
+                    const name = callee.name.text;
+                    const declaration = decl.members.find((member) => ts.isMethodDeclaration(member) &&
+                        member.body !== undefined &&
+                        (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) &&
+                        member.name.text === name);
+                    if (!declaration?.body || declaration.asteriskToken)
+                        return null;
+                    const modifiers = ts.getModifiers(declaration) ?? [];
+                    if (modifiers.some((m) => m.kind === ts.SyntaxKind.StaticKeyword || m.kind === ts.SyntaxKind.AsyncKeyword))
+                        return null;
+                    const isPrivate = ts.isPrivateIdentifier(declaration.name) ||
+                        modifiers.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword);
+                    return isPrivate ? declaration.body : null;
+                },
+            });
         // The deferred definite-assignment check: a field on the unguarded
         // list passes only with an unconditional `this.x = ...` at the
         // constructor's TOP LEVEL — the same standard the JS-class path
@@ -2642,7 +2677,7 @@ mixin) {
                 }
             }
             for (const f of unguardedFields) {
-                if (topAssigned.has(f.name))
+                if (topAssigned.has(f.name) || escape.assigned?.has(f.name))
                     continue;
                 // DEFERRED INITIALIZATION (the Output.initialize idiom —
                 // `stream!: T` assigned inside a method the constructor calls):
@@ -2676,6 +2711,23 @@ mixin) {
                 lowerer.unsupported("SC1090", f.node, f.why);
             }
         }
+        if (escape.assigned && !inst) {
+            for (const f of fieldOrder) {
+                if (f.redeclared || escape.assigned.has(f.name) || deferredInitFields.has(f.name))
+                    continue;
+                if (paramProps.some((pp) => pp.name === f.name))
+                    continue;
+                const declared = fields.get(f.name);
+                if (declared?.kind !== "object" || lowerer.classes.get(declared.className)?.def.runtime)
+                    continue;
+                const armed = lowerer.withUndefinedArm(declared);
+                if (armed === null || armed.kind !== "union")
+                    continue;
+                fields.set(f.name, armed);
+                f.type = armed;
+                deferredInitFields.add(f.name);
+            }
+        }
         // Partial overrides of an inherited accessor pair. JS gives the
         // derived class ONE own accessor property that SHADOWS the whole
         // inherited pair — the missing half does NOT resolve to the base's
@@ -3056,6 +3108,7 @@ mixin) {
                 ? { classDecorators: { nodes: classDecoratorNodes } }
                 : {}),
             ...(deferredInitFields.size > 0 ? { deferredInitFields } : {}),
+            ...(escape.escapes ? { constructionEscapes: true } : {}),
         };
         // GENERIC members get their declaring-class backlink now that the
         // info exists (instance lowering reads it for `this` typing and the
@@ -3939,7 +3992,13 @@ export function lowerStaticFieldRead(lowerer, expr) {
         lowerer.unsupported("SC1090", expr, `reading the private static '${expr.name.text}' 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 (found?.field !== undefined) {
-        return lowerer.maybeNarrow({ kind: "varRef", localId: found.field.globalId, type: found.field.type, loc }, expr);
+        const value = {
+            kind: "varRef",
+            localId: found.field.globalId,
+            type: found.field.type,
+            loc,
+        };
+        return found.field.runtimeOptional ? value : lowerer.maybeNarrow(value, expr);
     }
     if (found) {
         return staticMethodValue(lowerer, found.declarer, expr.name.text, found.method, expr, loc);
@@ -4752,7 +4811,13 @@ export function lowerClassValueProperty(lowerer, expr) {
         lowerer.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)`);
     }
     if (found.field !== undefined) {
-        return lowerer.maybeNarrow({ kind: "varRef", localId: found.field.globalId, type: found.field.type, loc }, expr);
+        const value = {
+            kind: "varRef",
+            localId: found.field.globalId,
+            type: found.field.type,
+            loc,
+        };
+        return found.field.runtimeOptional ? value : lowerer.maybeNarrow(value, expr);
     }
     return staticMethodValue(lowerer, found.declarer, member, found.method, expr, loc);
 }
@@ -4770,6 +4835,20 @@ function abstractMemberSignature(lowerer, member) {
         ret: lowerer.declaredReturnType(member, member.name),
     };
 }
+/** A nominal return subtype uses the same owned pointer as the inherited
+ * return slot. The current class is still being collected, so consult its
+ * already collected base chain before the complete class graph is available. */
+function overrideReturnAbi(lowerer, declared, inherited, className, base) {
+    if (declared.kind !== "object" || inherited.kind !== "object")
+        return declared;
+    if (lowerer.isSubclassOf(declared.className, inherited.className) ||
+        (declared.className === className &&
+            base !== null &&
+            (base.def.name === inherited.className ||
+                lowerer.isSubclassOf(base.def.name, inherited.className))))
+        return inherited;
+    return declared;
+}
 /** The nearest declaration of `name` at or above `info` — the method a
  * receiver of that static class runs when nothing below overrides it. */
 export function findMethodOn(lowerer, info, name) {
@@ -4933,34 +5012,7 @@ export function collectInheritedJsFieldWrites(lowerer, files) {
  * hierarchy identifies the original declarations through aliases as well. */
 export function collectVirtualJsMethods(lowerer, files) {
     const families = [];
-    // Record named prototype accesses before collecting method signatures.
-    // Those slots need a callable ABI even when JavaScript would otherwise
-    // specialize each call independently.
-    for (const file of files)
-        ts.walkPreorder(file, (node) => {
-            if (!ts.isPropertyAccessExpression(node) && !ts.isElementAccessExpression(node))
-                return;
-            const name = ts.isPropertyAccessExpression(node)
-                ? node.name.text
-                : ts.isStringLiteralLike(node.argumentExpression)
-                    ? node.argumentExpression.text
-                    : null;
-            if (name === null)
-                return;
-            const prototype = ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "prototype";
-            const assigned = ts.isBinaryExpression(node.parent) &&
-                node.parent.left === node &&
-                node.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken;
-            const symbol = !assigned
-                ? undefined
-                : ts.isPropertyAccessExpression(node)
-                    ? lowerer.checker.getSymbolAtLocation(node.name)
-                    : lowerer.checker.getPropertyOfType(lowerer.typeOf(node.expression), name);
-            if (prototype ||
-                (symbol && lowerer.checker.declarationsOf(symbol).some(ts.isMethodDeclaration))) {
-                lowerer.prototypeMethodAccesses.set(name, node);
-            }
-        });
+    collectClassMethodMutations(lowerer, files);
     const visit = (node) => {
         if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
             const accessors = node.members.filter((member) => (ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) &&
@@ -7273,7 +7325,7 @@ export function lowerNew(lowerer, expr) {
             if (targs[1]) {
                 lowerer.unsupported("SC1090", expr, `Map values of type '${lowerer.checker.typeToString(targs[1])}' ` +
                     `(Map values must be number, string, boolean, records, class instances, ` +
-                    `arrays, promises, Maps, Sets, or unions of those — not functions, 'unknown', or 'any')`);
+                    `typed arrays, arrays, promises, Maps, Sets, or supported unions and checked values)`);
             }
             lowerer.badType(expr, tsType);
         }