@scriptc/compiler 0.0.11 → 0.0.13

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

@@ -17,7 +17,7 @@ import { STREAM_API_MEMBERS, STREAM_PROP_MEMBERS, UNDERSCORE_METHODS, lowerStrea
 import { emitOverrideShapeReason, emitSpecSuperForward, emitterRooted, lowerEmitterSuperCall } from "./lower-emitter.js";
 import { declSymbolOf } from "./lower-modules.js";
 import { uniqueSymbolKeyOf } from "./lower-exprs.js";
-import { lowerHttpServerNew } from "./lower-server.js";
+import { lowerHttpAgentNew, lowerHttpServerNew } from "./lower-server.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead } from "./lower-namespaces.js";
 import { mixinResultBindingClassOf } from "./lower-mixins.js";
 /** The KEY symbol behind a LATE-BOUND (`__@name@id`) property: resolved
@@ -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
@@ -4351,6 +4377,14 @@ export function lowerNew(L, expr) {
         if (httpServer)
             return httpServer;
     }
+    // `new http.Agent(opts?)` / `new https.Agent(opts?)` — the Agent
+    // handle (lower-server): getName/destroy/counters through the dyn
+    // handle ops, requests thread it via the agent option.
+    {
+        const agent = lowerHttpAgentNew(L, expr);
+        if (agent)
+            return agent;
+    }
     if (ts.isIdentifier(expr.expression)) {
         // `import C = N.C; new C()` — the alias's own source-order guards
         // (a no-op for every non-import= binding).
@@ -4362,7 +4396,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 +4657,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 +4690,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 +4790,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 {
@@ -4992,7 +5026,7 @@ export function lowerNew(L, expr) {
     // of the generic construction rejection.
     {
         const STDLIB_CTOR_HINTS = {
-            Agent: "constructing an http Agent (compiled clients dial one connection per request and close it with the response — pass agent: false for Node's one-shot semantics, or omit the option)",
+            Agent: "constructing an http Agent through an indirect class binding (spell the construction on the module binding — new http.Agent(...)/new https.Agent(...) or the named Agent import — which lowers to the Agent handle)",
         };
         const ctorName = ts.isIdentifier(expr.expression)
             ? expr.expression