@scriptc/compiler 0.0.28 → 0.0.30

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

@@ -10,12 +10,12 @@ import { isGenericCallableMemberType, typeKey } from "../types.js";
 import { PoisonError, dynFallbackType, dynUndefinedExpr, importCallHandleType, jsFuncNameOf, newFnCtx, nodeThrowExpr } from "./lowerer.js";
 import { enforceLibBoundary } from "./lib-boundary.js";
 import { NARROW_FIRST, builtinFenceHintOf, builtinModuleFnOf } from "./surfaces.js";
-import { ffiBindingDiag, ffiSignatureDiag, requiresDynamicDiag } from "../../diagnostics/diagnostic.js";
+import { ffiBindingDiag, ffiSignatureDiag, libCallbackDiag, requiresDynamicDiag } from "../../diagnostics/diagnostic.js";
 import { mixinFnShapeOf } from "./lower-mixins.js";
 import { bufEncoding, dynStringReceiver, lowerArrayFromCall, lowerDynArrayFilterCall, lowerDynArrayFlatMapCall, lowerGroupByStaticCall, lowerIteratorHelperCall, lowerObjectAssignIndexShape, lowerObjectFromEntriesCall, lowerObjectIterOverIndexShape, lowerRegexMethodCall, lowerStringMethodCall, lowerTupleReadMethodCall } from "./lower-containers.js";
 import { lowerChildStreamMethodCall, lowerCreateRequireCall, lowerDirentMethodCall, lowerFileHandleMethodCall, lowerPerfHooksCall, lowerProcStreamMethodCall, lowerReflectApplyCall, lowerWatcherMethodCall } from "./lower-builtins.js";
-import { droppableStatic, lowerPromiseAllTupleCall, lowerPromiseRejectCall, probeLower, templateRawTextOf } from "./lower-exprs.js";
-import { httpClientFnBindingOf, isStreamUndefCallExpr, lowerHttpClientFnCall } from "./lower-server.js";
+import { droppableStatic, lowerAbsenceProbe, lowerPromiseAllTupleCall, lowerPromiseRejectCall, probeLower, templateRawTextOf } from "./lower-exprs.js";
+import { httpClientFnBindingOf, isStreamUndefCallExpr, lowerCompatReqStreamOptionalCall, lowerHttpClientFnCall } from "./lower-server.js";
 import { EMITTER_API_MEMBERS, exactInstanceClassOf, findGenericMethodOn, lowerClassGenericMethodCall, lowerStaticMethodCall } from "./lower-classes.js";
 import { emitterRooted, lowerEmitterMethodCall } from "./lower-emitter.js";
 import { lowerConsoleInspectArg, lowerFormatCall } from "./lower-inspect.js";
@@ -2313,29 +2313,59 @@ function ffiCallbackInputDiagnostic(L, descriptor, callbackType) {
     }
     return null;
 }
+/** Values returned by native code flow into TypeScript, so a declaration
+ * must admit the whole scalar domain the ABI class can produce. `mapType`
+ * intentionally widens literal and enum types to their storage type; that
+ * is sound for script-owned values but not for an external return contract
+ * (`(): true` cannot describe a bool callback that is free to return false). */
+function ffiReturnDomainDiagnostic(L, nativeClass, returnType) {
+    if (nativeClass === "void")
+        return null;
+    const domain = nativeClass === "bool" ? "boolean" : "number";
+    const coversDomain = nativeClass === "bool"
+        ? (returnType.flags & ts.TypeFlags.Boolean) !== 0
+        : (returnType.flags & ts.TypeFlags.Number) !== 0;
+    return coversDomain
+        ? null
+        : `the return type is '${L.checker.typeToString(returnType)}', but native class '${nativeClass}' may supply ` +
+            `any ${domain}; declare it as '${domain}'`;
+}
+/** The binding surface's diagnostic flavor: native-manifest bindings
+ * speak the SC5002/SC5003 FFI codes; library-mode host callbacks are the
+ * same recognition machinery under the profile's vocabulary — SC4024 for
+ * both the binding and signature halves, with "manifest" respelled
+ * "profile" in the shared detail strings so the teaching names the
+ * document the author actually edits. */
+function ffiFlavor(L) {
+    if (!L.libraryCallbacks)
+        return { binding: ffiBindingDiag, signature: ffiSignatureDiag };
+    const lib = (name, detail, loc) => libCallbackDiag(name, detail.replaceAll("manifest", "profile"), loc);
+    return { binding: lib, signature: lib };
+}
 /** The declaration half of an outbound FFI binding. Kept independent of
  * call-site argument checks so the whole manifest can be validated even
  * when a configured function is never called. */
 function ffiDeclarationDiagnostic(L, binding, symbol, loc) {
+    const { binding: bindingDiag, signature: signatureDiag } = ffiFlavor(L);
     const declarations = L.checker.declarationsOf(symbol);
     const functionDecls = declarations.filter(ts.isFunctionDeclaration);
     if (functionDecls.length === 0 ||
         declarations.some((decl) => !ts.isFunctionDeclaration(decl)) ||
         functionDecls.some((decl) => decl.body !== undefined)) {
-        return ffiBindingDiag(binding.name, "the configured name does not resolve exclusively to signature-only function declarations", loc);
+        return bindingDiag(binding.name, "the configured name does not resolve exclusively to signature-only function declarations", loc);
     }
     if (functionDecls.some((decl) => (decl.typeParameters?.length ?? 0) > 0)) {
-        return ffiSignatureDiag(binding.name, "generic ambient declarations cannot describe one fixed C ABI", loc);
+        return signatureDiag(binding.name, "generic ambient declarations cannot describe one fixed C ABI", loc);
     }
     const signatures = L.checker.getCallSignatures(L.checker.getTypeOfSymbol(symbol));
     if (signatures.length !== 1) {
-        return ffiSignatureDiag(binding.name, `the ambient binding has ${signatures.length} call signatures; exactly one non-overloaded signature is required`, loc);
+        return signatureDiag(binding.name, `the ambient binding has ${signatures.length} call signatures; exactly one non-overloaded signature is required`, loc);
     }
     const signature = signatures[0];
     const params = signature.getParameters();
     const sourceParams = ffiSourceParams(binding);
     if (params.length !== sourceParams.length) {
-        return ffiSignatureDiag(binding.name, `the TypeScript declaration has ${params.length} parameter(s), but the manifest declares ${sourceParams.length} source parameter(s) ` +
+        return signatureDiag(binding.name, `the TypeScript declaration has ${params.length} parameter(s), but the manifest declares ${sourceParams.length} source parameter(s) ` +
             `(${binding.params.length - sourceParams.length} additional native context slot(s) are compiler-supplied)`, loc);
     }
     const expectedParams = ffiSourceParamTypes(binding.params);
@@ -2347,18 +2377,18 @@ function ffiDeclarationDiagnostic(L, binding, symbol, loc) {
         // declaration is different: it is a callable external contract, so a
         // `never` slot cannot truthfully describe any native parameter.
         if ((paramType.flags & ts.TypeFlags.Never) !== 0) {
-            return ffiSignatureDiag(binding.name, `parameter ${i + 1} is 'never', an uninhabited TypeScript type that cannot describe a native ABI parameter`, loc);
+            return signatureDiag(binding.name, `parameter ${i + 1} is 'never', an uninhabited TypeScript type that cannot describe a native ABI parameter`, loc);
         }
         if (isFfiCallbackParam(sourceParam)) {
             const callbackDiagnostic = ffiCallbackInputDiagnostic(L, sourceParam, paramType);
             if (callbackDiagnostic !== null) {
-                return ffiSignatureDiag(binding.name, callbackDiagnostic, loc);
+                return signatureDiag(binding.name, callbackDiagnostic, loc);
             }
         }
         const mapped = L.mapTypeOf(paramType);
         const expected = expectedParams[i];
         if (mapped === null || !typeEquals(mapped, expected)) {
-            return ffiSignatureDiag(binding.name, `parameter ${i + 1} maps to '${mapped === null ? L.checker.typeToString(paramType) : L.fmt(mapped)}', ` +
+            return signatureDiag(binding.name, `parameter ${i + 1} maps to '${mapped === null ? L.checker.typeToString(paramType) : L.fmt(mapped)}', ` +
                 `which does not fit manifest ${ffiParamDisplay(sourceParam)}`, loc);
         }
     }
@@ -2367,21 +2397,36 @@ function ffiDeclarationDiagnostic(L, binding, symbol, loc) {
     // let tsc erase all control flow after the call while the linked function
     // continues, making the generated program disagree with TypeScript.
     if ((returnType.flags & ts.TypeFlags.Never) !== 0) {
-        return ffiSignatureDiag(binding.name, "the return type is 'never', but a native ABI return cannot uphold TypeScript's non-returning contract", loc);
+        return signatureDiag(binding.name, "the return type is 'never', but a native ABI return cannot uphold TypeScript's non-returning contract", loc);
     }
     const declaredReturn = L.mapTypeOf(returnType);
     const expectedReturn = ffiClassType(binding.returns);
     if (declaredReturn === null || !typeEquals(declaredReturn, expectedReturn)) {
-        return ffiSignatureDiag(binding.name, `the return maps to '${declaredReturn === null ? L.checker.typeToString(returnType) : L.fmt(declaredReturn)}', ` +
+        return signatureDiag(binding.name, `the return maps to '${declaredReturn === null ? L.checker.typeToString(returnType) : L.fmt(declaredReturn)}', ` +
             `which does not fit manifest class '${binding.returns}'`, loc);
     }
+    const returnDomainDiagnostic = ffiReturnDomainDiagnostic(L, binding.returns, returnType);
+    if (returnDomainDiagnostic !== null) {
+        return signatureDiag(binding.name, returnDomainDiagnostic, loc);
+    }
     return null;
 }
+/** True when a library callback may claim declarations from this file.
+ * Ordinary program source is always eligible. Declaration files are
+ * eligible only when they are project-owned: the standard library and
+ * installed/workspace package declarations are existing ambient surfaces,
+ * never callback declarations merely because a profile channel shares their
+ * spelling. */
+function libraryCallbackOwnsFile(L, file) {
+    return !file.isDeclarationFile || (!L.isStdlibFile(file) && !L.isNpmFile(file));
+}
 /** Resolve and validate every configured outbound binding before emit.
  * Candidate declarations are signature-only functions bearing the manifest
  * name anywhere in the program. Multiple scoped declarations are all native
  * bindings under the existing name-based call surface, so every candidate
- * must fit the one manifest ABI. */
+ * must fit the one manifest ABI. Library callbacks additionally exclude
+ * standard-library and package declaration files while retaining project
+ * declaration files as authored callback surface. */
 export function validateFfiImports(L) {
     const diagnostics = [];
     const symbolsByName = new Map();
@@ -2390,6 +2435,8 @@ export function validateFfiImports(L) {
     if (configuredNames.size === 0)
         return { diagnostics, symbolsByName };
     for (const file of L.program.getSourceFiles()) {
+        if (L.libraryCallbacks && !libraryCallbackOwnsFile(L, file))
+            continue;
         ts.walkPreorder(file, (node) => {
             if (ts.isFunctionDeclaration(node)) {
                 if (node.body === undefined &&
@@ -2415,7 +2462,23 @@ export function validateFfiImports(L) {
     for (const binding of L.ffiImports) {
         const bySymbol = candidates.get(binding.name);
         if (bySymbol === undefined || bySymbol.size === 0) {
-            diagnostics.push(ffiBindingDiag(binding.name, "the program has no signature-only function declaration with this name", { file: L.entry.fileName, start: 0, end: 0 }));
+            // A native-manifest binding with no declaration is a broken build
+            // input. A library callback channel with no declaration is unused
+            // CAPACITY: the registration symbol still dispatches it, nothing
+            // calls it, and a later program revision may (a program that calls
+            // the name without declaring it fails ordinary typechecking first).
+            if (!L.libraryCallbacks) {
+                diagnostics.push(ffiBindingDiag(binding.name, "the program has no signature-only function declaration with this name", { file: L.entry.fileName, start: 0, end: 0 }));
+            }
+            else {
+                // Preserve the distinction between unused capacity and a binding
+                // whose program declaration was found but failed validation. The
+                // latter deliberately leaves no map entry so calls poison without
+                // duplicating the program-level diagnostic; the empty set lets call
+                // lowering inspect same-named builtins, implementations, and
+                // unsupported ambient declaration shapes individually.
+                symbolsByName.set(binding.name, new Set());
+            }
             continue;
         }
         const validSymbols = new Set();
@@ -2444,15 +2507,37 @@ export function lowerFfiCall(L, expr) {
     if (!ts.isIdentifier(expr.expression))
         return null;
     const binding = L.ffiImportsByName.get(expr.expression.text);
-    if (binding === undefined)
+    if (binding === undefined) {
+        // LIBRARY mode with a declared callback surface: a CALL of a
+        // program-authored signature-only ambient function that names no
+        // channel is the author reaching for the host seam the profile does
+        // not provide — refuse with the callback teaching instead of the
+        // ambient ReferenceError lowering. Scoped to project-owned source and
+        // declaration files so lib.d.ts/@types/package ambients (parseInt,
+        // setTimeout, …) keep every existing lowering; callback-free profiles
+        // are untouched.
+        if (L.libraryCallbacks) {
+            const symbol = L.resolveValueSymbol(expr.expression);
+            const decls = symbol === null ? [] : L.checker.declarationsOf(symbol);
+            const callbackShaped = decls.length > 0 &&
+                decls.every((decl) => ts.isFunctionDeclaration(decl) &&
+                    decl.body === undefined &&
+                    libraryCallbackOwnsFile(L, decl.getSourceFile()));
+            if (callbackShaped) {
+                L.pushDiag(libCallbackDiag(expr.expression.text, "the profile declares no callback channel with this name", locOf(expr)));
+                throw new PoisonError();
+            }
+        }
         return null;
+    }
     const loc = locOf(expr);
+    const { binding: bindingFlavor, signature: signatureFlavor } = ffiFlavor(L);
     const bindingError = (detail) => {
-        L.pushDiag(ffiBindingDiag(binding.name, detail, loc));
+        L.pushDiag(bindingFlavor(binding.name, detail, loc));
         throw new PoisonError();
     };
     const signatureError = (detail) => {
-        L.pushDiag(ffiSignatureDiag(binding.name, detail, loc));
+        L.pushDiag(signatureFlavor(binding.name, detail, loc));
         throw new PoisonError();
     };
     const symbol = L.resolveValueSymbol(expr.expression) ??
@@ -2464,10 +2549,39 @@ export function lowerFfiCall(L, expr) {
         if (validSymbols === undefined)
             throw new PoisonError();
         if (!validSymbols.has(symbol)) {
-            // TypeScript resolved this call to a distinct local declaration.
-            // The manifest owns only the exact validated ambient binding; a
-            // same-named function with a body remains ordinary scriptc code.
-            return null;
+            if (L.libraryCallbacks) {
+                const declarations = L.checker.declarationsOf(symbol);
+                const programDeclarations = declarations.filter((decl) => libraryCallbackOwnsFile(L, decl.getSourceFile()));
+                const programAmbient = programDeclarations.length > 0 &&
+                    programDeclarations.every((decl) => decl.getSourceFile().isDeclarationFile ||
+                        (ts.getCombinedModifierFlags(decl) &
+                            ts.ModifierFlags.Ambient) !== 0);
+                if (programAmbient) {
+                    // A called, program-authored ambient with a configured channel
+                    // name is not unused capacity. Validate the resolved symbol now
+                    // so unsupported declaration forms (`declare const cb: ...`)
+                    // refuse SC4024 instead of silently dropping the call. A valid
+                    // declaration missed by the up-front syntax walk may proceed as
+                    // the callback binding after this exact-symbol check.
+                    const diagnostic = ffiDeclarationDiagnostic(L, binding, symbol, loc);
+                    if (diagnostic !== null) {
+                        L.pushDiag(diagnostic);
+                        throw new PoisonError();
+                    }
+                }
+                else {
+                    // Standard-library/package ambients and same-named program
+                    // implementations remain their ordinary TypeScript bindings;
+                    // the profile does not claim them.
+                    return null;
+                }
+            }
+            else {
+                // TypeScript resolved this call to a distinct local declaration.
+                // The manifest owns only the exact validated ambient binding; a
+                // same-named function with a body remains ordinary scriptc code.
+                return null;
+            }
         }
     }
     else {
@@ -2558,6 +2672,9 @@ export function lowerCall(L, expr) {
     const processOptional = L.lowerProcessOptionalMethodCall(expr);
     if (processOptional)
         return processOptional;
+    const reqStreamOptional = lowerCompatReqStreamOptionalCall(L, expr);
+    if (reqStreamOptional)
+        return reqStreamOptional;
     // `t.unref?.()` on a Timeout handle — same story: the method always
     // exists, so the optional call is the call.
     if (expr.questionDotToken && ts.isPropertyAccessExpression(expr.expression)) {
@@ -2565,20 +2682,13 @@ export function lowerCall(L, expr) {
         if (timeoutOptional)
             return timeoutOptional;
     }
-    // `req.stream?.on(...)` — the http2 compatibility request's h2-only
-    // stream member, guarded. The allowHTTP1 lowering serves every
-    // connection as HTTP/1.1, where Node answers undefined for req.stream:
-    // the optional chain short-circuits, the arguments never evaluate, and
-    // the whole statement is a no-op — exactly what lowers here (a VOID
-    // no-op the emitter drops). The receiver is restricted to an
-    // identifier so no evaluation is skipped, and to statement position so
-    // no value is consumed (an unguarded or computed use meets the pointed
-    // per-member fence in lower-server.ts instead).
+    // `req.session?.m(...)` remains absent on compatibility requests. Live
+    // `req.stream` calls now pass through the normal optional-chain and h2
+    // stream lowering using lowerServerProperty's checked getter.
     if (ts.isPropertyAccessExpression(expr.expression) &&
         ts.isPropertyAccessExpression(expr.expression.expression) &&
         !expr.expression.expression.questionDotToken &&
-        (expr.expression.expression.name.text === "stream" ||
-            expr.expression.expression.name.text === "session") &&
+        expr.expression.expression.name.text === "session" &&
         ts.isIdentifier(expr.expression.expression.expression) &&
         L.mapTypeOf(L.typeOf(expr.expression.expression.expression))?.kind === "httpReq" &&
         L.isStdlibMember(expr.expression.expression)) {
@@ -3203,10 +3313,63 @@ export function lowerCall(L, expr) {
                 const x = L.lowerExprExpecting(expr.arguments[0], F64);
                 return { kind: "libCall", fn: "num.isNaN", args: [x], type: BOOL, loc };
             }
-            const s = L.lowerExprExpecting(expr.arguments[0], STRING);
             const radix = expr.arguments[1]
                 ? L.lowerExprExpecting(expr.arguments[1], F64)
                 : { kind: "numLit", value: 0, type: F64, loc };
+            const optional = lowerAbsenceProbe(L, expr.arguments[0]);
+            if (optional?.type.kind === "union") {
+                const def = L.unions.get(optional.type.unionId);
+                const stringTag = def?.arms.findIndex((arm) => arm.kind === "string") ?? -1;
+                if (def &&
+                    stringTag >= 0 &&
+                    def.arms.every((arm) => arm.kind === "string" || isUnitType(arm))) {
+                    const unionT = optional.type;
+                    const key = `parseInt.optional:${unionT.unionId}`;
+                    let helper = L.widthHelpers.get(key);
+                    if (!helper) {
+                        helper = `%parseInt.optional.${L.widthHelpers.size}`;
+                        L.widthHelpers.set(key, helper);
+                        const value = { kind: "varRef", localId: "value.0", type: unionT, loc };
+                        const radixRef = { kind: "varRef", localId: "radix.0", type: F64, loc };
+                        const body = def.arms.flatMap((arm, tag) => isUnitType(arm)
+                            ? [{
+                                    kind: "if",
+                                    cond: { kind: "unionIsTag", unionId: unionT.unionId, tag, negated: false, value, type: BOOL, loc },
+                                    then: [{ kind: "return", value: { kind: "numLit", value: NaN, type: F64, loc }, loc }],
+                                    else_: null,
+                                    loc,
+                                }]
+                            : []);
+                        body.push({
+                            kind: "return",
+                            value: {
+                                kind: "libCall",
+                                fn: "num.parseInt",
+                                args: [{ kind: "unionNarrow", unionId: unionT.unionId, tag: stringTag, value, type: STRING, loc }, radixRef],
+                                type: F64,
+                                loc,
+                            },
+                            loc,
+                        });
+                        L.liftedFns.push({
+                            name: helper,
+                            params: [
+                                { localId: "value.0", name: "value", type: unionT },
+                                { localId: "radix.0", name: "radix", type: F64 },
+                            ],
+                            returnType: F64,
+                            locals: [
+                                { id: "value.0", name: "value", type: unionT, mutable: true },
+                                { id: "radix.0", name: "radix", type: F64, mutable: true },
+                            ],
+                            body,
+                            loc,
+                        });
+                    }
+                    return { kind: "call", callee: helper, args: [optional, radix], type: F64, loc };
+                }
+            }
+            const s = L.lowerExprExpecting(expr.arguments[0], STRING);
             return { kind: "libCall", fn: "num.parseInt", args: [s, radix], type: F64, loc };
         }
         // STATIC parseFloat/isFinite over exactly-typed arguments —