@scriptc/compiler 0.0.12 → 0.0.13

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

@@ -17,7 +17,7 @@ import { unsupportedModuleFeatureOf } from "../shared.js";
 import { fenceEnumObjectValue, lowerEnumAccess } from "./lower-enums.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, contextualUndefReadType, fenceEarlyAliasUse, fenceEarlyNsMemberRef, lowerNsIdentifierValue, nsMemberIdentOf, nsUndefRead, nsWritableTarget } from "./lower-namespaces.js";
 import { expandoMemberRead, expandoWritableTarget } from "./lower-expando.js";
-import { lowerSocketInstanceOf } from "./lower-server.js";
+import { lowerSocketInstanceOf, lowerTlsRootCertificates } from "./lower-server.js";
 import { findGenericMethodOn, lowerStaticFieldRead } from "./lower-classes.js";
 import { bindingNeverReassigned, implicitMonoFile, lowerTaggedTemplate, nullishGenericBindingUnitOf, objLitGenericFnInfoOf, objLitGenericFnNodeOf, requireObjLitGenericReceiver } from "./lower-calls.js";
 import { mixinFnOfCallee } from "./lower-mixins.js";
@@ -693,10 +693,11 @@ function lowerExprInner(L, expr) {
             if (acc)
                 return acc;
         }
-        // A binding destructured from http2.constants: the baked literal
-        // (the declaration emitted nothing — http2ConstantsDestructureDecl).
+        // A binding destructured from a baked constants object
+        // (http2.constants / crypto.constants): the literal — the
+        // declaration emitted nothing (builtinConstantsDestructureDecl).
         {
-            const h2c = L.http2ConstantBindingOf(expr);
+            const h2c = L.builtinConstantBindingOf(expr);
             if (h2c)
                 return h2c;
         }
@@ -715,6 +716,14 @@ function lowerExprInner(L, expr) {
                 if (bi.module === "module" && bi.member === "builtinModules") {
                     return builtinModulesArrayLit(loc);
                 }
+                // tls.rootCertificates: a runtime-valued module constant (the
+                // cached bundled-CA array) — the one member read that lowers
+                // to a libCall instead of a baked literal.
+                {
+                    const roots = lowerTlsRootCertificates(L, bi, loc);
+                    if (roots)
+                        return roots;
+                }
                 // JavaScript sources: a builtin member taken as a bare VALUE is
                 // the same identity-token story as stdlib globals above (the
                 // harness adds worker_threads.Worker to its identity Set).
@@ -1447,7 +1456,7 @@ function lowerExprInner(L, expr) {
             L.lowerFsConstantsProperty(expr) ??
             // http2.constants.NGHTTP2_CANCEL (any constants-object spelling):
             // the baked-literal table.
-            L.lowerHttp2ConstantsProperty(expr) ??
+            L.lowerBuiltinConstantsProperty(expr) ??
             // Builtin namespace imports (`path.sep`, `os.EOL`,
             // `fs.constants.R_OK` where the root is `import * as ...`): the
             // same constants and per-member fences as named builtin imports.
@@ -1858,7 +1867,8 @@ export function lowerTernary(L, expr, expected) {
         // tagged element type the checker's own type doesn't spell).
         const own = L.mapTypeOf(L.typeOf(expr));
         const useCtx = (ctxMapped?.kind === "record" || ctxMapped?.kind === "union" || ctxMapped?.kind === "object") &&
-            (own === null || (own.kind === "union" && !typeEquals(own, ctxMapped)));
+            (own === null ||
+                (own.kind === "union" && !typeEquals(own, ctxMapped) && !L.inLogicalLeftPosition(expr)));
         // Mixed dyn/unit arms under an unmappable own type (`typeof pkg.name
         // === "string" ? pkg.name : null` — the lowering world types the
         // unknown-receiver read `any`, which a static build cannot hold):
@@ -5518,7 +5528,10 @@ export function lowerRecordKeyRead(L, expr, shapeId, shape) {
         let dk = litKey !== null
             ? { kind: "strLit", value: litKey, type: STRING, loc: locOf(keyNode) }
             : L.lowerExpr(keyNode);
-        if (dk.type.kind === "f64")
+        // Number AND checked-dynamic keys ride the JS-exact formatter —
+        // property keys ARE strings (o[k] is o[String(k)] in JS), and a dyn
+        // key (agent.sockets[agent.getName(...)]) stringifies the same way.
+        if (dk.type.kind === "f64" || dk.type.kind === "dyn")
             dk = L.ensureString(dk, keyNode);
         if (dk.type.kind !== "string") {
             L.unsupported("SC1090", keyNode, "indexing records with non-string or non-number keys");
@@ -6612,6 +6625,30 @@ export function lowerBinary(L, expr) {
             // shapes lower through lowerCondition's bool descent instead.
             const target = L.mapTypeOf(L.typeOf(expr));
             if (target?.kind === "union") {
+                // `||` whose left does NOT fit the result union: the checker built
+                // that result by DROPPING the left's falsy arms (`process.env.X ||
+                // null` is `string | null`, `|| 3000` is `string | number` — the
+                // `undefined` is gone from both), so coercing the left eagerly, as
+                // the shared shape below does, retags an arm the test is about to
+                // rule out and throws where Node yields the default. Single-eval
+                // instead: test the left in its OWN union and retag only on the
+                // truthy side, where the dropped arms are unreachable. `&&` keeps
+                // the eager shape — there the falsy left IS the result, so the
+                // checker keeps those arms in the target and they must coerce.
+                if (op === ts.SyntaxKind.BarBarToken && left.type.kind === "union" && !typeEquals(left.type, target)) {
+                    const retag = L.unionRetagHelper(left.type.unionId, target.unionId, loc);
+                    if (retag) {
+                        L.requireTruthyUnion(left.type.unionId, expr);
+                        return {
+                            kind: "orDefault",
+                            left,
+                            right: L.coerceInto(expr.right, right, target),
+                            retag,
+                            type: target,
+                            loc,
+                        };
+                    }
+                }
                 L.requireTruthyUnion(target.unionId, expr);
                 return {
                     kind: "logical",
@@ -6978,6 +7015,12 @@ export function lowerBinary(L, expr) {
                 typeEquals(idLeft.type, idRight.type)) {
                 return { kind: "bin", op: negated ? "!==" : "===", left: idLeft, right: idRight, type: BOOL, loc };
             }
+            // Runtime HANDLES are objects to === too: one handle per socket/
+            // request/response, so pointer identity IS JS's object equality
+            // (`c.pause() === c` — Node's chaining assertions). */
+            if (DYN_HANDLE_KINDS.has(idLeft.type.kind) && typeEquals(idLeft.type, idRight.type)) {
+                return { kind: "bin", op: negated ? "!==" : "===", left: idLeft, right: idRight, type: BOOL, loc };
+            }
             L.unsupported("SC1043", expr);
             break;
         }
@@ -8077,6 +8120,25 @@ export function lowerInExpression(L, expr, loc) {
         const rIn = lowerRuntimeKeyIn(L, expr, loc);
         if (rIn)
             return rIn;
+        // A runtime key over a CHECKED-DYNAMIC receiver (`name in
+        // agent.sockets` — both sides computed; the checker may type the
+        // receiver as a Dict while the VALUE lives in the checked-dynamic tree, so the
+        // LOWERED type decides): the dyn presence answer, with the key
+        // stringified like every property key (o[k] is o[String(k)] in JS;
+        // `in` shares the coercion).
+        {
+            const probed = probeLower(L, expr.right);
+            if (probed?.type.kind === "dyn") {
+                let k = L.lowerExpr(expr.left); // JS order: the key evaluates first
+                if (k.type.kind === "f64" || k.type.kind === "string" || k.type.kind === "dyn") {
+                    k = L.ensureString(k, expr.left);
+                    const recvD = L.lowerExpr(expr.right);
+                    if (recvD.type.kind === "dyn") {
+                        return { kind: "libCall", fn: "dyn.hasKey", args: [recvD, k], type: BOOL, loc };
+                    }
+                }
+            }
+        }
         L.unsupported("SC1090", expr.left, "'in' with computed (non-literal) keys (a const whose type is one string literal folds; a string-typed key answers over index-signature record receivers)");
     }
     // A receiver re-read (the static folds below) is safe for plain reads