@scriptc/compiler 0.0.11 → 0.0.12

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

@@ -474,6 +474,32 @@ export function collectClassShape(L, decl) {
             }
         }
     }
+    // A poisoned BASE this class EXTENDS must report EAGERLY for the same
+    // reason: the derived statement evaluates its heritage when module
+    // init reaches it (these are top-level declarations), and the base's
+    // fence is the COMPILER's, not Node's — Node defines the base fine and
+    // runs on — so a deferred trap there is a manufactured divergence, not
+    // the Node-parity deferral is licensed by (classFieldSuperAccessibleJs2:
+    // the binary refused at `class D extends C` where Node prints five
+    // lines). Leaf poisoned classes stay deferred — only the extends edge
+    // reports. Resolution runs under the collect pass's guard (this is
+    // collectProgram), so the lookup neither flushes nor fences.
+    {
+        const baseIdent = decl.heritageClauses
+            ?.find((h) => h.token === ts.SyntaxKind.ExtendsKeyword)
+            ?.types.map((t) => t.expression)
+            .filter(ts.isIdentifier)[0];
+        const baseSym = baseIdent ? L.resolveValueSymbol(baseIdent) : null;
+        const baseDiags = baseSym ? L.deferredDiags.get(baseSym) : undefined;
+        if (baseSym && baseDiags) {
+            L.deferredDiags.delete(baseSym);
+            if (!L.alreadyFlushed.has(baseSym)) {
+                L.flushedSymbols.add(baseSym);
+                for (const d of baseDiags)
+                    L.pushDiag(d);
+            }
+        }
+    }
 }
 export function collectClassShapeInner(L, decl, jsNameOverride, inst, 
 /** MIXIN instantiation mode (lower-mixins.ts): the class inside a
@@ -4362,7 +4388,7 @@ export function lowerNew(L, expr) {
         // like Node's message property default.
         const errInfo = L.builtinErrorInfoOf(symbol);
         // `new DOMException(message?, nameOrOptions?)`: both arguments cross
-        // as DOM values (absent → the DOM undefined), and the runtime owns
+        // as dyn values (absent → the dyn undefined), and the runtime owns
         // WebIDL's resolution — ToString of the message ("" for undefined),
         // name from a string / an options object's `name` member (with the
         // `cause` own-property record) / "Error" for absent, and the legacy
@@ -4623,7 +4649,7 @@ export function lowerNew(L, expr) {
             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
+            // WeakMap stance below — the VALUE lowers as an opaque dyn 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
@@ -4656,7 +4682,7 @@ export function lowerNew(L, expr) {
         // `new WeakMap()` / `new WeakSet()` in JAVASCRIPT sources: no weak
         // container exists in the value model, but harness code constructs
         // one unconditionally and touches it only on paths tests don't
-        // reach — the value lowers as an opaque DOM object (identity only;
+        // reach — the value lowers as an opaque dyn object (identity only;
         // every reached METHOD use meets its own per-site fence → runtime
         // fence). TypeScript keeps the compile fence.
         if ((symbol?.name === "WeakMap" || symbol?.name === "WeakSet") &&
@@ -4756,14 +4782,14 @@ export function lowerNew(L, expr) {
             // `new Promise(setImmediate)` (the Node-suite early-exit shape):
             // the executor IS the stdlib setImmediate, so resolve rides the
             // immediate queue — a dedicated runtime constructor arms an
-            // immediate that fulfills with the undefined DOM value.
+            // immediate that fulfills with the undefined dyn value.
             {
                 const a0 = args[0];
                 if (ts.isIdentifier(a0) && a0.text === "setImmediate") {
                     const sym = L.checker.getSymbolAtLocation(a0);
                     const decls = sym ? L.checker.declarationsOf(sym) : [];
                     if (decls.length > 0 && decls.every((d) => L.isStdlibFile(d.getSourceFile()))) {
-                        // The settled value is the undefined DOM value — the result
+                        // The settled value is the undefined dyn value — the result
                         // is promise<dyn> whatever T the checker inferred for the
                         // unusual executor (Promise<unknown> in the suite's shape).
                         return {