@scriptc/compiler 0.1.3 → 0.1.4

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

@@ -23,7 +23,7 @@ import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUn
 import { expandoMemberRead, expandoWritableTarget } from "./lower-expando.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 { bindingNeverReassigned, funcTypeFromParamShapes, implicitMonoFile, lowerTaggedTemplate, nullishGenericBindingUnitOf, objLitGenericFnInfoOf, objLitGenericFnNodeOf, requireObjLitGenericReceiver } from "./lower-calls.js";
 import { mixinFnOfCallee } from "./lower-mixins.js";
 import { isConstAssertionTypeNode, isGenericCallableMemberType, isParseArgsDynTypeName, underConstAssertion, unitOnlyUnion } from "../type-mapper.js";
 import { lowerYield } from "./lower-generators.js";
@@ -34,6 +34,7 @@ import { hasOptionalChainGuard, isOptionalChainTail, isRequireMainFilename } fro
 import { conditionalSpreadOf, foldedStringKeyOf } from "./expressions/object-literals.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { fenceNodeModuleMutation, isNodeModuleValue, lowerNodeModuleIdentifier, lowerNodeModuleProperty, lowerRequireCacheElement, lowerRequireCacheHas, lowerRequireMainProperty } from "./lower-node-module.js";
+import { lowerAbstractEquality } from "./abstract-equality.js";
 /** A template piece's RAW text (String.raw's contract: escapes stay
  * characters). 7's client AST ships no rawText at runtime (the typing
  * declares it; the serialized node data omits it), so the raw span comes
@@ -598,6 +599,7 @@ function lowerExprInner(lowerer, expr) {
             symbol: "symbol",
             map: "object", set: "object", promise: "object", bytes: "object",
             regexp: "object", generator: "object", classval: "function",
+            moduleNs: "object",
             undefinedT: "undefined", nullT: "object",
         };
         const folded = FOLD[operand.type.kind];
@@ -649,13 +651,22 @@ function lowerExprInner(lowerer, expr) {
         if (expr.text === "arguments" && lowerer.ctx.argumentsLocal) {
             return { kind: "varRef", localId: lowerer.ctx.argumentsLocal.id, type: DYN, loc };
         }
-        // A `const x = promisify(execFile)` binding as a VALUE: the
-        // promisified function never exists at runtime (its calls lower to
-        // the interned async-exec helper) — call it directly.
+        // A compiler-projected adapter as a VALUE: the adapter has no
+        // runtime function object (its calls rewrite directly) — call it
+        // through its immutable binding instead.
         {
             const sym = lowerer.resolveValueSymbol(expr);
-            if (sym && lowerer.promisifiedExecFile.has(sym)) {
-                lowerer.unsupported("SC1090", expr, `a promisified execFile as a value (call '${expr.text}' directly)`);
+            const projection = sym ? lowerer.staticCallables.get(sym) : undefined;
+            if (projection?.kind === "promisified-exec-file" || projection?.kind === "promisified-builtin") {
+                lowerer.unsupported("SC1090", expr, `a promisified builtin as a value (call '${expr.text}' directly)`);
+            }
+            if (projection?.kind === "builtin-function") {
+                if (!isJsSourceFile(expr.getSourceFile())) {
+                    const callable = lowerer.lowerBuiltinCallableValue(projection, loc);
+                    if (callable)
+                        return callable;
+                }
+                lowerer.unsupported("SC1090", expr, `a builtin function alias as an escaping value (call '${expr.text}' directly)`);
             }
         }
         // Union-typed bindings read through tsc's control-flow narrowing:
@@ -809,17 +820,12 @@ function lowerExprInner(lowerer, expr) {
         if (sig && lowerer.isTopLevelFnSymbol(expr)) {
             // A declared function used as a value: a zero-capture closure. The
             // backend interns one per function so `f === f` holds (JS identity).
-            // The value's type is the completed ABI signature — exact-arity, so
-            // optional/default/rest declarations pass the value fence first.
+            // The value's type is the completed ABI signature; optional/default
+            // slots and typed rest arrays pass the value fence first.
             lowerer.noteEdge(sig.name);
             // dynRest slots stay out of the VALUE type's param list (fn.length
             // semantics); the rest marker carries the trailing dyn-array ABI.
-            const funcType = {
-                kind: "func",
-                params: sig.params.filter((p) => p.mode !== "dynRest").map((p) => p.type),
-                ret: sig.returnType,
-                ...(sig.params.some((p) => p.mode === "dynRest") ? { rest: true } : {}),
-            };
+            const funcType = funcTypeFromParamShapes(sig.params, sig.returnType);
             lowerer.requireExactArityValue(expr, expr, sig.params, funcType);
             return { kind: "closure", fnName: sig.name, captures: [], type: funcType, loc };
         }
@@ -879,6 +885,11 @@ function lowerExprInner(lowerer, expr) {
                 if (isJsSourceFile(expr.getSourceFile())) {
                     return { kind: "strLit", value: `[builtin ${bi.module}.${bi.member}]`, type: STRING, loc };
                 }
+                {
+                    const callable = lowerer.lowerBuiltinCallableValue(bi, loc);
+                    if (callable)
+                        return callable;
+                }
                 if (builtinModuleFnOf(lowerer, bi.module, bi.member)) {
                     lowerer.unsupported("SC1090", expr, `library functions as values (call '${expr.text}' directly)`);
                 }
@@ -889,7 +900,12 @@ function lowerExprInner(lowerer, expr) {
         // the namespace object has no representation — members lower at
         // their access sites only. The CommonJS namespace binding
         // (`const lib = require("./lib.js")`) gets the same fence.
-        if (lowerer.builtinNamespaceModuleOf(expr) !== null || lowerer.cjsLocalModuleBindingOf(expr)) {
+        const builtinNamespace = lowerer.builtinNamespaceModuleOf(expr);
+        if (builtinNamespace !== null) {
+            const type = { kind: "moduleNs", moduleId: `builtin:${builtinNamespace}` };
+            return { kind: "moduleNsRef", moduleId: type.moduleId, type, loc };
+        }
+        if (lowerer.cjsLocalModuleBindingOf(expr)) {
             lowerer.unsupported("SC1090", expr, `module namespace objects as values (access '${expr.text}' members directly)`);
         }
         if (lowerer.islandGlobalFnOf(expr)) {
@@ -941,11 +957,14 @@ function lowerExprInner(lowerer, expr) {
         // type-mapper.ts pins the one concrete signature `(value: string) =>
         // primitive`; direct calls `String(x)` never reach here — the call
         // lowering intercepts them with the wider static coercions).
-        // JavaScript sources keep the identity-token path below.
+        const jsPrimitiveCtorSelector = isJsSourceFile(expr.getSourceFile()) &&
+            expr.parent !== undefined &&
+            ts.isArrowFunction(expr.parent) &&
+            expr.parent.body === expr;
         if ((expr.text === "String" || expr.text === "Number" || expr.text === "Boolean") &&
-            !isJsSourceFile(expr.getSourceFile()) &&
+            (!isJsSourceFile(expr.getSourceFile()) || jsPrimitiveCtorSelector) &&
             lowerer.isStdlibSymbol(lowerer.checker.getSymbolAtLocation(expr))) {
-            return primitiveCtorClosure(lowerer, expr.text, loc);
+            return primitiveCtorClosure(lowerer, expr.text, loc, jsPrimitiveCtorSelector);
         }
         // The lib fence's IDENTIFIER chokepoint: the real standard library
         // resolves names the old minimal ambient world never declared
@@ -1081,6 +1100,15 @@ function lowerExprInner(lowerer, expr) {
         // representation (ambient namespaces compile to Node's
         // ReferenceError instead — the object never exists at runtime).
         {
+            const moduleNs = lowerer.mapTypeOf(lowerer.typeOf(expr));
+            if (moduleNs?.kind === "moduleNs") {
+                return { kind: "moduleNsRef", moduleId: moduleNs.moduleId, type: moduleNs, loc };
+            }
+            const builtinNs = lowerer.builtinNamespaceModuleOf(expr);
+            if (builtinNs !== null) {
+                const type = { kind: "moduleNs", moduleId: `builtin:${builtinNs}` };
+                return { kind: "moduleNsRef", moduleId: type.moduleId, type, loc };
+            }
             const ns = lowerNsIdentifierValue(lowerer, expr);
             if (ns)
                 return ns;
@@ -3084,10 +3112,10 @@ export function lowerIntrinsicProperty(lowerer, expr) {
             const receiver = lowerer.lowerExpr(expr.expression);
             return { kind: "libCall", fn: "child.killed", args: [receiver], type: BOOL, loc };
         }
-        if (name === "on" || name === "kill" || name === "unref") {
+        if (name === "on" || name === "once" || name === "kill" || name === "unref") {
             lowerer.unsupported("SC1090", expr, `child methods as values (call '${name}' directly)`);
         }
-        lowerer.noLowering(`ChildProcess.${name}`, expr, "on(\"exit\" | \"error\", cb), pid, exitCode, killed, kill(signal?), and unref() are the supported ChildProcess members", lowerer.checker.getSymbolAtLocation(expr.name));
+        lowerer.noLowering(`ChildProcess.${name}`, expr, "on/once(\"exit\" | \"close\" | \"error\", cb), pid, exitCode, killed, kill(signal?), and unref() are the supported ChildProcess members", lowerer.checker.getSymbolAtLocation(expr.name));
     }
     if (kind === "spawnRes") {
         // The spawnSync-result reads. status is the interned `number | null`
@@ -3137,7 +3165,7 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         if (name === "isFile" || name === "isDirectory") {
             lowerer.unsupported("SC1090", expr, `Stats methods as values (call '${name}' directly)`);
         }
-        lowerer.noLowering(`Stats.${name}`, expr, "isFile(), isDirectory(), isSymbolicLink(), size, blocks, nlink, atimeMs, and mtimeMs are the supported Stats members", lowerer.checker.getSymbolAtLocation(expr.name));
+        lowerer.noLowering(`Stats.${name}`, expr, "isFile(), isDirectory(), isSymbolicLink(), dev, ino, size, blocks, nlink, atimeMs, mtimeMs, and ctimeMs are the supported Stats members", lowerer.checker.getSymbolAtLocation(expr.name));
     }
     if (kind === "date") {
         const methods = new Set([
@@ -3178,22 +3206,30 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         // serialization: lowercased hostname, `:port` appended exactly when
         // a non-default port is present (scr_url_host — Node-exact,
         // opaque-path URLs answer ""); `hostname` is the stored port-less
-        // host field verbatim (Node would keep IPv6 brackets here, but the
-        // parser rejects IPv6 hosts — documented divergence — so the getter
-        // never sees one).
-        if (name === "protocol" || name === "pathname" || name === "href" || name === "host" || name === "hostname" || name === "search") {
+        // host field verbatim, including IPv6 brackets.
+        if (name === "protocol" || name === "origin" || name === "username" || name === "password" || name === "pathname" || name === "href" || name === "host" || name === "hostname" || name === "port" || name === "search" || name === "hash") {
             const receiver = lowerer.lowerExpr(expr.expression);
             const fn = name === "protocol"
                 ? "url.protocol"
-                : name === "pathname"
-                    ? "url.pathname"
-                    : name === "host"
-                        ? "url.host"
-                        : name === "hostname"
-                            ? "url.hostname"
-                            : name === "search"
-                                ? "url.search"
-                                : "url.href";
+                : name === "origin"
+                    ? "url.origin"
+                    : name === "username"
+                        ? "url.username"
+                        : name === "password"
+                            ? "url.password"
+                            : name === "pathname"
+                                ? "url.pathname"
+                                : name === "host"
+                                    ? "url.host"
+                                    : name === "hostname"
+                                        ? "url.hostname"
+                                        : name === "port"
+                                            ? "url.port"
+                                            : name === "search"
+                                                ? "url.search"
+                                                : name === "hash"
+                                                    ? "url.hash"
+                                                    : "url.href";
             return { kind: "libCall", fn, args: [receiver], type: STRING, loc: locOf(expr) };
         }
         // `u.searchParams`: the LIVE cached view (one identity per URL —
@@ -3206,7 +3242,7 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         if (name === "toString" || name === "toJSON") {
             lowerer.unsupported("SC1090", expr, `URL methods as values (call '${name}' directly)`);
         }
-        lowerer.noLowering(`URL.${name}`, expr, "protocol, pathname, href, host, hostname, search, searchParams, and toString() are the supported URL members", lowerer.checker.getSymbolAtLocation(expr.name));
+        lowerer.noLowering(`URL.${name}`, expr, "protocol, origin, username, password, pathname, href, host, hostname, port, search, hash, searchParams, and toString() are the supported URL members", lowerer.checker.getSymbolAtLocation(expr.name));
     }
     if (kind === "searchParams") {
         const SEARCH_PARAMS_METHODS = new Set(["get", "getAll", "set", "append", "delete", "has", "sort", "toString", "forEach", "keys", "values", "entries"]);
@@ -5229,7 +5265,14 @@ export function lowerPrefixUnary(lowerer, expr) {
             if (raw.type.kind === "bigint") {
                 return { kind: "libCall", fn: "bigint.not", args: [raw], type: BIGINT_T, loc };
             }
-            const operand = lowerOptionalNumber(lowerer, raw, loc, expr.operand);
+            // A checked-dynamic value retains enough JavaScript structure to
+            // run exact ToNumber, including the object valueOf/toString
+            // protocol. This is the static `any`/JS-lane answer for idioms
+            // such as `while (~index)`, where inference may have widened an
+            // otherwise numeric slot to the checked-dynamic tree.
+            const operand = raw.type.kind === "dyn"
+                ? { kind: "libCall", fn: "dyn.toNumberCoerce", args: [raw], type: F64, loc }
+                : lowerOptionalNumber(lowerer, raw, loc, expr.operand);
             if (operand.type.kind !== "f64")
                 lowerer.unsupported("SC1043", expr);
             return { kind: "unary", op: "~", operand, type: F64, loc };
@@ -5518,23 +5561,10 @@ export function lowerBinary(lowerer, expr) {
         const nullTest = lowerLooseNullCompare(lowerer, expr, loc);
         if (nullTest)
             return nullTest;
-        // SAME-KIND loose equality IS strict equality (the spec's ==
-        // dispatches to === when both operands share a type): `typeof v ==
-        // 'object'`, `n != 0`, `flag == true` all lower exactly. Mixed
-        // kinds (where == coerces) keep the fence.
-        {
-            const negated = op === ts.SyntaxKind.ExclamationEqualsToken;
-            const left = lowerer.lowerExpr(expr.left);
-            const right = lowerer.lowerExpr(expr.right);
-            if (left.type.kind === "string" && right.type.kind === "string") {
-                return { kind: "strEq", negated, left, right, type: BOOL, loc };
-            }
-            if ((left.type.kind === "f64" && right.type.kind === "f64") ||
-                (left.type.kind === "bool" && right.type.kind === "bool")) {
-                return { kind: "bin", op: negated ? "!==" : "===", left, right, type: BOOL, loc };
-            }
-        }
-        lowerer.unsupported("SC1040", expr);
+        const loose = lowerAbstractEquality(lowerer, lowerer.lowerExpr(expr.left), lowerer.lowerExpr(expr.right), op === ts.SyntaxKind.ExclamationEqualsToken, loc);
+        if (loose)
+            return loose;
+        lowerer.unsupported("SC1040", expr, undefined, "object-to-primitive loose equality can call user-defined valueOf/toString methods — compare explicit primitive conversions instead");
     }
     if (op === ts.SyntaxKind.AmpersandAmpersandToken || op === ts.SyntaxKind.BarBarToken) {
         if (op === ts.SyntaxKind.BarBarToken) {
@@ -5558,6 +5588,15 @@ export function lowerBinary(lowerer, expr) {
         if (left.kind === "unitLit") {
             return op === ts.SyntaxKind.BarBarToken ? right : left;
         }
+        // JS objects and symbols are always truthy. In `ref || fallback`
+        // the fallback is therefore unreachable and the result is the
+        // already-evaluated left value — the browser-fallback idiom used by
+        // packages for `process.argv || []` and `process.env || {}`. The
+        // operand itself remains in the IR, preserving reads/calls that
+        // produce the reference; only the unreachable right lowering drops.
+        if (op === ts.SyntaxKind.BarBarToken && REF_TRUTHY_KINDS.has(left.type.kind)) {
+            return left;
+        }
         if (left.type.kind === "dyn" || right.type.kind === "dyn") {
             // A checked-dynamic operand (`fn.name || '<anonymous>'` —
             // test/common's _mustCallInner): both sides live in the checked-dynamic tree and
@@ -6253,6 +6292,9 @@ export function lowerBinary(lowerer, expr) {
             if (idLeft.type.kind === "classval" && idRight.type.kind === "classval") {
                 return { kind: "bin", op: negated ? "!==" : "===", left: idLeft, right: idRight, type: BOOL, loc };
             }
+            if (idLeft.type.kind === "moduleNs" && idRight.type.kind === "moduleNs") {
+                return { kind: "bin", op: negated ? "!==" : "===", left: idLeft, right: idRight, type: BOOL, loc };
+            }
             if ((idLeft.type.kind === "array" ||
                 idLeft.type.kind === "map" ||
                 idLeft.type.kind === "set" ||
@@ -7359,10 +7401,10 @@ function lowerInExpression(lowerer, expr, loc) {
     // Compile-time-known STRING keys fold — literals, and the same
     // const/enum-literal and template folding computed property keys get
     // (foldedStringKeyOf); runtime-valued keys keep the fence.
-    // NUMERIC literal keys answer on ARRAY receivers: dense arrays hold
-    // exactly the indices [0, length), so `3 in xs` is a length test (and
-    // a negative/fractional literal is a constant miss — the receiver
-    // still evaluates once through its own length read).
+    // NUMERIC literal keys answer on ARRAY receivers through the shared
+    // presence query. Arrays retain holes independently from length, and
+    // noncanonical numeric keys live in their ordinary-property table, so
+    // a length comparison is not an honest `in` answer.
     {
         let kNode = expr.left;
         while (ts.isParenthesizedExpression(kNode))
@@ -7370,12 +7412,14 @@ function lowerInExpression(lowerer, expr, loc) {
         if (ts.isNumericLiteral(kNode) && lowerer.mapTypeOf(lowerer.typeOf(expr.right))?.kind === "array") {
             const recvArr = lowerer.lowerExpr(expr.right);
             if (recvArr.type.kind === "array") {
-                const len = { kind: "arrIntrinsic", method: "length", receiver: recvArr, args: [], type: F64, loc };
                 const n = Number(kNode.text);
-                if (Number.isInteger(n) && n >= 0) {
-                    return { kind: "bin", op: "<", left: { kind: "numLit", value: n, type: F64, loc }, right: len, type: BOOL, loc };
-                }
-                return { kind: "bin", op: "<", left: len, right: { kind: "numLit", value: 0, type: F64, loc }, type: BOOL, loc };
+                return {
+                    kind: "arrayHas",
+                    arr: recvArr,
+                    index: { kind: "numLit", value: n, type: F64, loc },
+                    type: BOOL,
+                    loc,
+                };
             }
         }
     }
@@ -9011,32 +9055,40 @@ function lowerStreamObjectProperty(lowerer, expr) {
     return lowerStreamProperty(lowerer, expr, info);
 }
 /** The primitive-constructor closure (`String`/`Number`/`Boolean` as a
- * VALUE): interns one synthesized module function per constructor —
- * `%builtin.String` et al. — and returns the zero-capture closure over it.
- * The body IS the string-coercion the type mapping promised
- * (`(value: string) => primitive`): String is identity, Number the ECMA
- * StringToNumber (num.fromString — the same runtime call the direct
- * `Number(s)` lowering emits), Boolean the emptiness test. Interning makes
- * every reference the SAME immortal closure, so `opt.type === String`
- * compares like JS function identity. */
-function primitiveCtorClosure(lowerer, name, loc) {
+ * VALUE): interns one synthesized module function per constructor/ABI and
+ * returns the zero-capture closure over it. Typed sources use the mapped
+ * `(value: string) => primitive` signature; a recognized JavaScript
+ * concise-arrow selector (`() => String`, the picocolors fallback) takes
+ * dyn so its ordinary coercion signature survives inference residue. The
+ * dyn bodies run exact ToString/ToNumber/ToBoolean, including object hooks.
+ * Interning makes every reference under one ABI the SAME immortal closure,
+ * so `opt.type === String` compares like JS function identity. */
+function primitiveCtorClosure(lowerer, name, loc, dynamicInput) {
     const ret = name === "String" ? STRING : name === "Number" ? F64 : BOOL;
-    const fnT = funcOf([STRING], ret);
-    let fnName = lowerer.primitiveCtorFns.get(name);
+    const input = dynamicInput ? DYN : STRING;
+    const fnT = funcOf([input], ret);
+    const key = `${name}:${dynamicInput ? "dyn" : "string"}`;
+    let fnName = lowerer.primitiveCtorFns.get(key);
     if (!fnName) {
-        fnName = `%builtin.${name}`;
-        lowerer.primitiveCtorFns.set(name, fnName);
-        const s = { kind: "varRef", localId: "v.0", type: STRING, loc };
-        const value = name === "String"
-            ? s
-            : name === "Number"
-                ? { kind: "libCall", fn: "num.fromString", args: [s], type: F64, loc }
-                : { kind: "strEq", negated: true, left: s, right: { kind: "strLit", value: "", type: STRING, loc }, type: BOOL, loc };
+        fnName = `%builtin.${name}${dynamicInput ? ".dyn" : ""}`;
+        lowerer.primitiveCtorFns.set(key, fnName);
+        const v = { kind: "varRef", localId: "v.0", type: input, loc };
+        const value = dynamicInput
+            ? name === "String"
+                ? { kind: "libCall", fn: "dyn.toStringCoerce", args: [v], type: STRING, loc }
+                : name === "Number"
+                    ? { kind: "libCall", fn: "dyn.toNumberCoerce", args: [v], type: F64, loc }
+                    : { kind: "dynTest", test: "truthy", value: v, type: BOOL, loc }
+            : name === "String"
+                ? v
+                : name === "Number"
+                    ? { kind: "libCall", fn: "num.fromString", args: [v], type: F64, loc }
+                    : { kind: "strEq", negated: true, left: v, right: { kind: "strLit", value: "", type: STRING, loc }, type: BOOL, loc };
         const fn = {
             name: fnName,
-            params: [{ localId: "v.0", name: "value", type: STRING }],
+            params: [{ localId: "v.0", name: "value", type: input }],
             returnType: ret,
-            locals: [{ id: "v.0", name: "value", type: STRING, mutable: false }],
+            locals: [{ id: "v.0", name: "value", type: input, mutable: false }],
             body: [{ kind: "return", value, loc }],
             loc,
         };