@scriptc/compiler 0.2.7 → 0.2.9

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. */

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

@@ -42,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";
@@ -999,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
@@ -1025,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) {
@@ -1696,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");
@@ -2059,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;
@@ -2187,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
@@ -2625,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
@@ -2645,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):
@@ -2679,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
@@ -3059,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