@scriptc/compiler 0.3.4 → 0.3.6

package/dist/frontend/lowering/lower-server.d.ts

@@ -31,7 +31,8 @@ export declare function lowerHttpResPropertyAssignment(lowerer: Lowerer, left: t
  * a separate protocol concern. */
 export declare function lowerHttpServerTimeoutAssignment(lowerer: Lowerer, left: ts.Expression, right: ts.Expression, loc: SrcLoc): IrStmt | null;
 /** `server.maxConnections = n`: the value crosses as a dyn (undefined
- * and null unset the cap). */
+ * and null unset the cap). `server.dropMaxConnection = v` stores the
+ * value as is (Node reads it only in cluster mode). */
 export declare function lowerNetServerMaxConnectionsAssignment(lowerer: Lowerer, left: ts.Expression, right: ts.Expression, loc: SrcLoc): IrStmt | null;
 /** The method-call dispatch for both server-surface receiver kinds — one
  * entry in lower-calls.ts's intrinsic chain (the lowerChildMethodCall

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

@@ -1045,11 +1045,13 @@ export function lowerHttpServerTimeoutAssignment(lowerer, left, right, loc) {
     };
 }
 /** `server.maxConnections = n`: the value crosses as a dyn (undefined
- * and null unset the cap). */
+ * and null unset the cap). `server.dropMaxConnection = v` stores the
+ * value as is (Node reads it only in cluster mode). */
 export function lowerNetServerMaxConnectionsAssignment(lowerer, left, right, loc) {
     if (!ts.isPropertyAccessExpression(left) || left.questionDotToken)
         return null;
-    if (left.name.text !== "maxConnections")
+    const name = left.name.text;
+    if (name !== "maxConnections" && name !== "dropMaxConnection")
         return null;
     if (lowerer.mapTypeOf(lowerer.typeOf(left.expression))?.kind !== "netServer")
         return null;
@@ -1061,7 +1063,9 @@ export function lowerNetServerMaxConnectionsAssignment(lowerer, left, right, loc
         kind: "exprStmt",
         expr: {
             kind: "libCall",
-            fn: "net.serverMaxConnectionsSet",
+            fn: name === "maxConnections"
+                ? "net.serverMaxConnectionsSet"
+                : "net.serverDropMaxConnectionSet",
             args: [receiver, value],
             type: VOID,
             loc,
@@ -1385,6 +1389,18 @@ function lowerNetServerMethodCall(lowerer, call, access) {
                 loc,
             };
         }
+        if (event === "checkContinue" || event === "checkExpectation") {
+            // Expect handling: these listeners take the request instead of
+            // 'request' (checkContinue answers with res.writeContinue()).
+            const cb = lowerRequestHandlerArg(lowerer, args[1]);
+            return {
+                kind: "libCall",
+                fn: "http.serverOnCheck",
+                args: [receiver, cb, once, boolLit(event === "checkExpectation", loc)],
+                type: VOID,
+                loc,
+            };
+        }
         if (event === "request") {
             // The 'request' event — http.createServer(handler)'s event twin, and
             // the way an http2 allowHTTP1 server (created handler-less) gets its
@@ -1518,7 +1534,7 @@ function lowerNetServerMethodCall(lowerer, call, access) {
                 loc,
             };
         }
-        lowerer.noLowering(`server.${name}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, args[0], '"connection", "request", "drop", "stream", "session", "upgrade", "connect", "error", "close", "listening", and "sessionError" are the supported server events (as literals)');
+        lowerer.noLowering(`server.${name}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, args[0], '"connection", "request", "checkContinue", "checkExpectation", "drop", "stream", "session", "upgrade", "connect", "error", "close", "listening", and "sessionError" are the supported server events (as literals)');
     }
     if (name === "emit") {
         // The demux route: emit("connection", socket) hands an accepted
@@ -1851,6 +1867,50 @@ function lowerNetSocketMethodCall(lowerer, call, access) {
             loc,
         };
     }
+    if ((name === "getProtocol" || name === "getCipher") && args.length === 0) {
+        // TLSSocket.getProtocol(): "TLSv1.2"/"TLSv1.3" or null;
+        // getCipher(): { name, standardName, version }.
+        const receiver = coerceToHandle(lowerer, access.expression, NETSOCKET_T);
+        const value = {
+            kind: "libCall",
+            fn: name === "getProtocol" ? "tls.sockGetProtocol" : "tls.sockGetCipher",
+            args: [receiver],
+            type: DYN,
+            loc,
+        };
+        const declared = lowerer.mapTypeOf(lowerer.typeOf(call));
+        return declared === null || declared.kind === "dyn"
+            ? value
+            : lowerer.coerceInto(call, value, declared);
+    }
+    if (name === "resetAndDestroy") {
+        // An RST close; a connecting socket resets once it connects. Answers
+        // the socket, Node's chaining.
+        if (args.length !== 0) {
+            lowerer.noLowering(`resetAndDestroy with ${args.length} arguments`, call, "the form is resetAndDestroy()");
+        }
+        const receiver = coerceToHandle(lowerer, access.expression, NETSOCKET_T);
+        return {
+            kind: "libCall",
+            fn: "net.sockResetAndDestroy",
+            args: [receiver],
+            type: NETSOCKET_T,
+            loc,
+        };
+    }
+    if (name === "address") {
+        // { address, family, port } or {} (connecting or destroyed): the
+        // declared AddressInfo | {} maps to a dyn value.
+        if (args.length !== 0) {
+            lowerer.noLowering(`address with ${args.length} arguments`, call, "address() takes no arguments");
+        }
+        const result = lowerer.mapTypeOf(lowerer.typeOf(call));
+        if (result?.kind !== "dyn") {
+            lowerer.noLowering("socket.address() where the result is not AddressInfo | {}", call, "use the declared AddressInfo | {} result, and narrow it with a type assertion");
+        }
+        const receiver = coerceToHandle(lowerer, access.expression, NETSOCKET_T);
+        return { kind: "libCall", fn: "net.sockAddress", args: [receiver], type: DYN, loc };
+    }
     if (name === "destroySoon") {
         // end() now, destroy once the FIN actually flushed — Node's
         // 'finish'-then-destroy.
@@ -2478,11 +2538,13 @@ export function lowerServerProperty(lowerer, expr) {
             const receiver = coerceToHandle(lowerer, expr.expression, NETSERVER_T);
             return { kind: "libCall", fn: "net.serverListening", args: [receiver], type: BOOL, loc };
         }
-        if (expr.name.text === "maxConnections") {
+        if (expr.name.text === "maxConnections" || expr.name.text === "dropMaxConnection") {
             const receiver = coerceToHandle(lowerer, expr.expression, NETSERVER_T);
             const value = {
                 kind: "libCall",
-                fn: "net.serverMaxConnectionsGet",
+                fn: expr.name.text === "maxConnections"
+                    ? "net.serverMaxConnectionsGet"
+                    : "net.serverDropMaxConnectionGet",
                 args: [receiver],
                 type: DYN,
                 loc,
@@ -2647,6 +2709,24 @@ export function lowerServerProperty(lowerer, expr) {
         const receiver = coerceToHandle(lowerer, expr.expression, NETSOCKET_T);
         return { kind: "libCall", fn: "tls.sockAuthorized", args: [receiver], type: BOOL, loc };
     }
+    if (recvKind === "netSocket" &&
+        lowerer.isStdlibMember(expr) &&
+        expr.name.text === "alpnProtocol") {
+        // TLSSocket.alpnProtocol: null before the handshake, then the
+        // negotiated protocol or false.
+        const receiver = coerceToHandle(lowerer, expr.expression, NETSOCKET_T);
+        const value = {
+            kind: "libCall",
+            fn: "tls.sockAlpnProtocol",
+            args: [receiver],
+            type: DYN,
+            loc,
+        };
+        const declared = lowerer.mapTypeOf(lowerer.typeOf(expr));
+        return declared === null || declared.kind === "dyn"
+            ? value
+            : lowerer.coerceInto(expr, value, declared);
+    }
     if (recvKind === "netSocket" && expr.name.text === "authorizationError") {
         // TLSSocket.authorizationError — the verify-failure CODE STRING
         // (DEPTH_ZERO_SELF_SIGNED_CERT, ...) or null when authorized/never
@@ -2999,6 +3079,7 @@ function lowerHttpServerOptions(lowerer, node, what) {
     let joinDup = false;
     let allowMissingHost = false;
     let keepAliveTimeoutBuffer = null;
+    let maxHeaderSize = null;
     for (const prop of node.properties) {
         let initializer;
         if (ts.isPropertyAssignment(prop) &&
@@ -3037,6 +3118,17 @@ function lowerHttpServerOptions(lowerer, node, what) {
             }
             lowerer.noLowering(`${what} with a non-literal joinDuplicateHeaders option`, prop, 'the lowered forms are the literals joinDuplicateHeaders: true (repeats join ", ") and false (the keep-first default)');
         }
+        if (key === "maxHeaderSize") {
+            // The header size bound (Node's validateInteger runs in the runtime).
+            const raw = initializer !== null
+                ? lowerer.lowerExpr(initializer)
+                : lowerer.lowerShorthandValue(prop);
+            if (raw.type.kind !== "f64") {
+                lowerer.noLowering(`${what} with a '${lowerer.fmt(raw.type)}' maxHeaderSize option`, prop, "maxHeaderSize is a number");
+            }
+            maxHeaderSize = raw;
+            continue;
+        }
         if (key === "keepAliveTimeoutBuffer") {
             if (keepAliveTimeoutBuffer !== null) {
                 lowerer.noLowering(`${what} with duplicate keepAliveTimeoutBuffer options`, prop, "write keepAliveTimeoutBuffer once in the options literal");
@@ -3056,10 +3148,10 @@ function lowerHttpServerOptions(lowerer, node, what) {
             keepAliveTimeoutBuffer = value;
             continue;
         }
-        fenceOrDropOptionKey(lowerer, prop, key, what, HTTP_SERVER_DOCUMENTED_OPTIONS, "requireHostHeader, joinDuplicateHeaders, and keepAliveTimeoutBuffer are the supported options");
+        fenceOrDropOptionKey(lowerer, prop, key, what, HTTP_SERVER_DOCUMENTED_OPTIONS, "requireHostHeader, joinDuplicateHeaders, keepAliveTimeoutBuffer, and maxHeaderSize are the supported options");
         // An undocumented key, dropped like Node drops it.
     }
-    return { joinDup, allowMissingHost, keepAliveTimeoutBuffer };
+    return { joinDup, allowMissingHost, keepAliveTimeoutBuffer, maxHeaderSize };
 }
 /** The shared createServer([options][, handler]) shapes behind
  * http.createServer, http.Server, and `new http.Server`: no arguments
@@ -3085,7 +3177,12 @@ function lowerHttpCreateServerForms(lowerer, expr, what, loc) {
     }
     const opts = optsNode !== null
         ? lowerHttpServerOptions(lowerer, optsNode, what)
-        : { joinDup: false, allowMissingHost: false, keepAliveTimeoutBuffer: null };
+        : {
+            joinDup: false,
+            allowMissingHost: false,
+            keepAliveTimeoutBuffer: null,
+            maxHeaderSize: null,
+        };
     const server = handlerNode !== null
         ? {
             kind: "libCall",
@@ -3095,20 +3192,25 @@ function lowerHttpCreateServerForms(lowerer, expr, what, loc) {
             loc,
         }
         : { kind: "libCall", fn: "http.createServerEmpty", args: [], type: NETSERVER_T, loc };
-    if (!opts.joinDup && !opts.allowMissingHost && opts.keepAliveTimeoutBuffer === null)
+    if (!opts.joinDup &&
+        !opts.allowMissingHost &&
+        opts.keepAliveTimeoutBuffer === null &&
+        opts.maxHeaderSize === null)
         return server;
     // The option-setting composition: an interned helper takes the option
     // values first (preserving Node's options-before-handler evaluation
     // order), then the fresh server, applies the modeled fields, and answers
     // the server as the constructor/factory result.
     const hasBuffer = opts.keepAliveTimeoutBuffer !== null;
-    const key = `server.opts:${opts.joinDup ? 1 : 0}:${opts.allowMissingHost ? 1 : 0}:${hasBuffer ? 1 : 0}`;
+    const hasMax = opts.maxHeaderSize !== null;
+    const key = `server.opts:${opts.joinDup ? 1 : 0}:${opts.allowMissingHost ? 1 : 0}:${hasBuffer ? 1 : 0}:${hasMax ? 1 : 0}`;
     const existing = lowerer.arrHofHelpers.get(key);
     const name = existing ?? `%server.opts.${lowerer.arrHofHelpers.size}`;
     if (!existing) {
         lowerer.arrHofHelpers.set(key, name);
         const params = [
             ...(hasBuffer ? [{ localId: "b.0", name: "buffer", type: DYN }] : []),
+            ...(hasMax ? [{ localId: "m.0", name: "maxHeaderSize", type: F64 }] : []),
             { localId: "s.0", name: "s", type: NETSERVER_T },
         ];
         const ref = { kind: "varRef", localId: "s.0", type: NETSERVER_T, loc };
@@ -3128,6 +3230,19 @@ function lowerHttpCreateServerForms(lowerer, expr, what, loc) {
                 loc,
             });
         }
+        if (hasMax) {
+            body.push({
+                kind: "exprStmt",
+                expr: {
+                    kind: "libCall",
+                    fn: "http.serverMaxHeaderSize",
+                    args: [ref, { kind: "varRef", localId: "m.0", type: F64, loc }],
+                    type: VOID,
+                    loc,
+                },
+                loc,
+            });
+        }
         if (opts.joinDup) {
             body.push({
                 kind: "exprStmt",
@@ -3161,7 +3276,11 @@ function lowerHttpCreateServerForms(lowerer, expr, what, loc) {
     return {
         kind: "call",
         callee: name,
-        args: [...(opts.keepAliveTimeoutBuffer !== null ? [opts.keepAliveTimeoutBuffer] : []), server],
+        args: [
+            ...(opts.keepAliveTimeoutBuffer !== null ? [opts.keepAliveTimeoutBuffer] : []),
+            ...(opts.maxHeaderSize !== null ? [opts.maxHeaderSize] : []),
+            server,
+        ],
         type: NETSERVER_T,
         loc,
     };
@@ -4437,6 +4556,12 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
     let agentClose = null;
     /** agent: <Agent value> — the requestAgent rows thread the handle. */
     let agentVal = null;
+    /** signal: an AbortSignal (checked at runtime) that destroys the request. */
+    let signal = null;
+    /** servername: the TLS name for SNI and certificate verification. */
+    let servername = null;
+    /** maxHeaderSize: the response head's size bound. */
+    let maxHeaderSize = null;
     for (const prop of optsNode.properties) {
         // Shorthand entries ({ port } for { port: port }) are the natural
         // spelling at these call sites — the shorthand's VALUE lowering
@@ -4528,6 +4653,22 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
             case "timeout":
                 timeout = lowerVal("f64");
                 break;
+            case "maxHeaderSize":
+                maxHeaderSize = lowerVal("f64");
+                break;
+            case "servername":
+                if (!secureish) {
+                    lowerer.noLowering(`${member} option 'servername'`, prop, "servername is an https.request option — the plain http client has no TLS layer");
+                }
+                servername = lowerVal("string");
+                break;
+            case "signal": {
+                const v = initializer !== null
+                    ? lowerer.lowerExpr(initializer)
+                    : lowerer.lowerShorthandValue(prop);
+                signal = lowerer.coerceToExpected(v, DYN);
+                break;
+            }
             case "headers":
                 if (initializer === null) {
                     lowerer.noLowering(`${member} with a shorthand headers option`, prop, "spell it out: headers: theHeaders");
@@ -4612,8 +4753,8 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
             }
             default:
                 fenceOrDropOptionKey(lowerer, prop, key, member, secureish ? HTTPS_CLIENT_DOCUMENTED_OPTIONS : HTTP_CLIENT_DOCUMENTED_OPTIONS, secureish
-                    ? "hostname/host, port, path, method, timeout, headers, agent, rejectUnauthorized, and ca are the supported options"
-                    : "hostname/host, port, path, method, timeout, headers, and agent are the supported options");
+                    ? "hostname/host, port, path, method, timeout, headers, agent, signal, maxHeaderSize, rejectUnauthorized, ca, and servername are the supported options"
+                    : "hostname/host, port, path, method, timeout, headers, agent, signal, and maxHeaderSize are the supported options");
         }
     }
     if (agentClose !== null) {
@@ -4679,19 +4820,69 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
     timeout ??= numLit(0, loc);
     headers ??= { kind: "arrayLit", elems: [], type: arrayOf(STRING), loc };
     const autoEnd = boolLit(member === "get", loc);
+    // Options applied to the built request: servername before the TLS
+    // handshake starts, then options.signal (an already aborted signal
+    // destroys the request at once, like Node's constructor).
+    const withSignal = (request) => {
+        if (signal === null && servername === null && maxHeaderSize === null)
+            return request;
+        const local = lowerer.declareHiddenLocal("%requestOptions", HTTPCLIENTREQ_T);
+        const ref = () => varRef(local.id, HTTPCLIENTREQ_T, loc);
+        const steps = [{ kind: "varDecl", localId: local.id, init: request, loc }];
+        if (maxHeaderSize !== null) {
+            steps.push({
+                kind: "exprStmt",
+                expr: {
+                    kind: "libCall",
+                    fn: "http.clientMaxHeaderSize",
+                    args: [ref(), maxHeaderSize],
+                    type: VOID,
+                    loc,
+                },
+                loc,
+            });
+        }
+        if (servername !== null) {
+            steps.push({
+                kind: "exprStmt",
+                expr: {
+                    kind: "libCall",
+                    fn: "https.clientServername",
+                    args: [ref(), servername],
+                    type: VOID,
+                    loc,
+                },
+                loc,
+            });
+        }
+        if (signal !== null) {
+            steps.push({
+                kind: "exprStmt",
+                expr: { kind: "libCall", fn: "http.clientSignal", args: [ref(), signal], type: VOID, loc },
+                loc,
+            });
+        }
+        return { kind: "seqExpr", stmts: steps, result: ref(), type: HTTPCLIENTREQ_T, loc };
+    };
     if (connCb !== null) {
         const base = [connCb, path, method, timeout, headers, autoEnd];
         if (args.length === 1) {
-            return { kind: "libCall", fn: "http.requestConn", args: base, type: HTTPCLIENTREQ_T, loc };
+            return withSignal({
+                kind: "libCall",
+                fn: "http.requestConn",
+                args: base,
+                type: HTTPCLIENTREQ_T,
+                loc,
+            });
         }
         const { cb } = lowerCallbackArg(lowerer, args[1], "response callbacks", 1, (p) => p.kind === "httpReq", "use (res) or ()", [HTTPREQ_T]);
-        return {
+        return withSignal({
             kind: "libCall",
             fn: "http.requestConnCb",
             args: [...base, cb],
             type: HTTPCLIENTREQ_T,
             loc,
-        };
+        });
     }
     const base = [host, port, path, method, timeout, headers, autoEnd];
     if (secureish) {
@@ -4713,7 +4904,7 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
                 : agentVal !== null
                     ? "http.requestAgent"
                     : "http.request";
-        return { kind: "libCall", fn, args: base, type: HTTPCLIENTREQ_T, loc };
+        return withSignal({ kind: "libCall", fn, args: base, type: HTTPCLIENTREQ_T, loc });
     }
     const { cb } = lowerCallbackArg(lowerer, args[1], "response callbacks", 1, (p) => p.kind === "httpReq", "use (res) or ()", [HTTPREQ_T]);
     const fn = binding !== null
@@ -4725,7 +4916,7 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
             : agentVal !== null
                 ? "http.requestAgentCb"
                 : "http.requestCb";
-    return { kind: "libCall", fn, args: [...base, cb], type: HTTPCLIENTREQ_T, loc };
+    return withSignal({ kind: "libCall", fn, args: [...base, cb], type: HTTPCLIENTREQ_T, loc });
 }
 /** The headers option of http.request: an object literal with literal
  * keys and string values packs into the flat [k0, v0, k1, v1, ...] pairs
@@ -4941,6 +5132,22 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
         }
         lowerer.noLowering(`${name} of '${lowerer.fmt(data.type)}' data`, args[0] ?? call, NARROW_DATA_HINT);
     }
+    if (name === "destroy" && args.length === 1) {
+        // destroy(err): err is the request's 'error' (an Error value here).
+        requireStatementPosition(lowerer, call, "request.destroy(err)");
+        const receiver = lowerer.lowerExpr(access.expression);
+        const err = lowerer.lowerExpr(args[0]);
+        if (err.type.kind !== "object") {
+            lowerer.noLowering(`destroy with a '${lowerer.fmt(err.type)}' argument`, args[0], "pass an Error value, or call destroy() without one");
+        }
+        return {
+            kind: "libCall",
+            fn: "http.clientDestroyError",
+            args: [receiver, lowerer.coerceToExpected(err, ERROR_T)],
+            type: VOID,
+            loc,
+        };
+    }
     if (name === "destroy" || name === "abort") {
         requireStatementPosition(lowerer, call, `request.${name}()`);
         if (args.length !== 0) {
@@ -4991,7 +5198,11 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
                 loc,
             };
         }
-        if (event === "timeout" || event === "close" || event === "finish" || event === "abort") {
+        if (event === "timeout" ||
+            event === "close" ||
+            event === "finish" ||
+            event === "abort" ||
+            event === "continue") {
             const { cb } = lowerCallbackArg(lowerer, args[1], `${event} listeners`, 0, () => false, "use ()", []);
             const fn = event === "timeout"
                 ? "http.clientOnTimeout"
@@ -4999,7 +5210,9 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
                     ? "http.clientOnClose"
                     : event === "abort"
                         ? "http.clientOnAbort"
-                        : "http.clientOnFinish";
+                        : event === "continue"
+                            ? "http.clientOnContinue"
+                            : "http.clientOnFinish";
             return { kind: "libCall", fn, args: [receiver, cb, once], type: VOID, loc };
         }
         if (event === "upgrade") {