@scriptc/compiler 0.1.2 → 0.1.4

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

@@ -1517,6 +1517,14 @@ function headersSnapshotHelper(lowerer, shapeId, loc) {
         callArgs: [varRef("r.0", HTTPREQ_T, loc)],
     });
 }
+function trailersSnapshotHelper(lowerer, shapeId, loc) {
+    return pairsSnapshotHelper(lowerer, shapeId, loc, {
+        keyPrefix: "trailers",
+        libCall: "http.reqTrailerPairs",
+        params: [{ localId: "r.0", name: "r", type: HTTPREQ_T }],
+        callArgs: [varRef("r.0", HTTPREQ_T, loc)],
+    });
+}
 /** The `endStream` boolean of an h2 options object literal, as a literal
  * bool. Returns undefined when absent (or the arg is absent). Fences on
  * a non-literal endStream value or unknown keys that would matter. */
@@ -1829,11 +1837,12 @@ export function lowerServerProperty(lowerer, expr) {
             const fn = name === "aborted" ? "http.reqAborted" : "http.reqComplete";
             return { kind: "libCall", fn, args: [receiver], type: BOOL, loc };
         }
-        if (name === "rawHeaders") {
+        if (name === "rawHeaders" || name === "rawTrailers") {
             // [name, value, name, value, ...] in arrival order, names in their
             // ORIGINAL case — Node's shape; a fresh string[] per read.
             const receiver = coerceToHandle(lowerer, expr.expression, HTTPREQ_T);
-            return { kind: "libCall", fn: "http.reqRawHeaders", args: [receiver], type: arrayOf(STRING), loc };
+            const fn = name === "rawHeaders" ? "http.reqRawHeaders" : "http.reqRawTrailers";
+            return { kind: "libCall", fn, args: [receiver], type: arrayOf(STRING), loc };
         }
         if (name === "statusMessage") {
             // `string | undefined` — the reason phrase on client responses (""
@@ -1870,19 +1879,24 @@ export function lowerServerProperty(lowerer, expr) {
             // guarded-no-op / unguarded-TypeError stance; other reads fence.
             lowerer.noLowering(`reading '${name}' (an HTTP/2-only member) from a request`, expr, "compatibility requests do not expose their backing h2 stream/session yet; guarded method calls no-op and other reads have no lowering");
         }
-        if (name === "headers") {
+        if (name === "headers" || name === "trailers") {
             // `req.headers` as a VALUE — the `{ ...req.headers }` spread and
             // record flows: a fresh snapshot record per read (Node's spread
             // copies too; the per-name READS keep their direct lowerings).
             const mapped = lowerer.mapTypeOf(lowerer.typeOf(expr));
             if (mapped?.kind === "record") {
-                const helper = headersSnapshotHelper(lowerer, mapped.shapeId, loc);
+                const helper = name === "headers"
+                    ? headersSnapshotHelper(lowerer, mapped.shapeId, loc)
+                    : trailersSnapshotHelper(lowerer, mapped.shapeId, loc);
                 if (helper !== null) {
                     const receiver = coerceToHandle(lowerer, expr.expression, HTTPREQ_T);
                     return { kind: "call", callee: helper, args: [receiver], type: mapped, loc };
                 }
             }
-            lowerer.unsupported("SC1090", expr, "req.headers as a value of this type (read one header: req.headers.name or req.headers[name])");
+            lowerer.unsupported("SC1090", expr, `req.${name} as a value of this type (read one field: req.${name}.name or req.${name}[name])`);
+        }
+        if (name === "headersDistinct" || name === "trailersDistinct") {
+            lowerer.unsupported("SC1090", expr, `req.${name} as a value (read one name with req.${name}[name])`);
         }
     }
     if (recvKind === "httpRes" && lowerer.isStdlibMember(expr) && expr.name.text === "stream") {
@@ -1951,15 +1965,28 @@ export function lowerServerProperty(lowerer, expr) {
         const receiver = coerceToHandle(lowerer, expr.expression, HTTPCLIENTREQ_T);
         return { kind: "libCall", fn: "http.clientDestroyed", args: [receiver], type: BOOL, loc };
     }
-    if (isHttpReqHeaders(lowerer, expr.expression)) {
+    if (recvKind === "httpClientReq" && lowerer.isStdlibMember(expr) && expr.name.text === "writableCorked") {
+        const receiver = coerceToHandle(lowerer, expr.expression, HTTPCLIENTREQ_T);
+        return { kind: "libCall", fn: "http.clientWritableCorked", args: [receiver], type: F64, loc };
+    }
+    if (httpReqFieldCollection(lowerer, expr.expression) !== null) {
+        const collection = httpReqFieldCollection(lowerer, expr.expression);
         const receiver = coerceToHandle(lowerer, expr.expression.expression, HTTPREQ_T);
         const key = { kind: "strLit", value: expr.name.text, type: STRING, loc };
-        return { kind: "libCall", fn: "http.reqHeader", args: [receiver, key], type: lowerer.envValueType(), loc };
+        const fn = collection === "headers" ? "http.reqHeader"
+            : collection === "trailers" ? "http.reqTrailer"
+                : collection === "headersDistinct" ? "http.reqHeaderValues" : "http.reqTrailerValues";
+        const type = collection.endsWith("Distinct") ? lowerer.withUndefinedArm(arrayOf(STRING)) : lowerer.envValueType();
+        return { kind: "libCall", fn, args: [receiver, key], type, loc };
     }
     if (recvKind === "httpRes" && lowerer.isStdlibMember(expr) && expr.name.text === "headersSent") {
         const receiver = coerceToHandle(lowerer, expr.expression, HTTPRES_T);
         return { kind: "libCall", fn: "http.resHeadersSent", args: [receiver], type: BOOL, loc };
     }
+    if (recvKind === "httpRes" && lowerer.isStdlibMember(expr) && expr.name.text === "writableCorked") {
+        const receiver = coerceToHandle(lowerer, expr.expression, HTTPRES_T);
+        return { kind: "libCall", fn: "http.resWritableCorked", args: [receiver], type: F64, loc };
+    }
     if (recvKind === "httpRes" && lowerer.isStdlibMember(expr) && expr.name.text === "statusCode") {
         // 200 until assigned — Node's fresh-response default; the assignment
         // twin lives in lowerHttpResPropertyAssignment.
@@ -2084,6 +2111,7 @@ function lowerHttpServerOptions(lowerer, node, what) {
         lowerer.noLowering(`${what} with a non-literal options argument`, node, "pass the options as an object literal: { requireHostHeader?, joinDuplicateHeaders? }");
     }
     let joinDup = false;
+    let allowMissingHost = false;
     let keepAliveTimeoutBuffer = null;
     for (const prop of node.properties) {
         let initializer;
@@ -2099,13 +2127,15 @@ function lowerHttpServerOptions(lowerer, node, what) {
         }
         const key = prop.name.text;
         if (key === "requireHostHeader") {
-            // The literal `false` only: it asks for exactly this parser's
-            // behavior (requests without Host are served). Node's default
-            // (true: answer 400) is the behavior this slice does not have, so
-            // `true`/dynamic values fence instead of silently not enforcing.
-            if (initializer === null || initializer.kind !== ts.SyntaxKind.FalseKeyword) {
-                lowerer.noLowering(`${what} with a non-\`false\` requireHostHeader option`, prop, "this parser never answers 400 for a missing Host header — requireHostHeader: false is the honest (and only) lowered value");
+            if (initializer !== null && initializer.kind === ts.SyntaxKind.FalseKeyword) {
+                allowMissingHost = true;
+                continue;
             }
+            if (initializer !== null && initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                allowMissingHost = false;
+                continue;
+            }
+            lowerer.noLowering(`${what} with a non-literal requireHostHeader option`, prop, "the lowered forms are the literals requireHostHeader: true and false");
             continue;
         }
         if (key === "joinDuplicateHeaders") {
@@ -2116,7 +2146,8 @@ function lowerHttpServerOptions(lowerer, node, what) {
                 continue;
             }
             if (initializer !== null && initializer.kind === ts.SyntaxKind.FalseKeyword) {
-                continue; /* Node's default: repeats keep the first value */
+                joinDup = false; /* Node's default: repeats keep the first value */
+                continue;
             }
             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)");
         }
@@ -2139,10 +2170,10 @@ function lowerHttpServerOptions(lowerer, node, what) {
             keepAliveTimeoutBuffer = value;
             continue;
         }
-        fenceOrDropOptionKey(lowerer, prop, key, what, HTTP_SERVER_DOCUMENTED_OPTIONS, "requireHostHeader: false, joinDuplicateHeaders, and keepAliveTimeoutBuffer are the supported options");
+        fenceOrDropOptionKey(lowerer, prop, key, what, HTTP_SERVER_DOCUMENTED_OPTIONS, "requireHostHeader, joinDuplicateHeaders, and keepAliveTimeoutBuffer are the supported options");
         // An undocumented key, dropped like Node drops it.
     }
-    return { joinDup, keepAliveTimeoutBuffer };
+    return { joinDup, allowMissingHost, keepAliveTimeoutBuffer };
 }
 /** The shared createServer([options][, handler]) shapes behind
  * http.createServer, http.Server, and `new http.Server`: no arguments
@@ -2168,18 +2199,18 @@ function lowerHttpCreateServerForms(lowerer, expr, what, loc) {
     }
     const opts = optsNode !== null
         ? lowerHttpServerOptions(lowerer, optsNode, what)
-        : { joinDup: false, keepAliveTimeoutBuffer: null };
+        : { joinDup: false, allowMissingHost: false, keepAliveTimeoutBuffer: null };
     const server = handlerNode !== null
         ? { kind: "libCall", fn: "http.createServer", args: [lowerRequestHandlerArg(lowerer, handlerNode)], type: NETSERVER_T, loc }
         : { kind: "libCall", fn: "http.createServerEmpty", args: [], type: NETSERVER_T, loc };
-    if (!opts.joinDup && opts.keepAliveTimeoutBuffer === null)
+    if (!opts.joinDup && !opts.allowMissingHost && opts.keepAliveTimeoutBuffer === 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}:${hasBuffer ? 1 : 0}`;
+    const key = `server.opts:${opts.joinDup ? 1 : 0}:${opts.allowMissingHost ? 1 : 0}:${hasBuffer ? 1 : 0}`;
     const existing = lowerer.arrHofHelpers.get(key);
     const name = existing ?? `%server.opts.${lowerer.arrHofHelpers.size}`;
     if (!existing) {
@@ -2206,6 +2237,13 @@ function lowerHttpCreateServerForms(lowerer, expr, what, loc) {
                 loc,
             });
         }
+        if (opts.allowMissingHost) {
+            body.push({
+                kind: "exprStmt",
+                expr: { kind: "libCall", fn: "http.serverAllowMissingHostHeader", args: [ref], type: VOID, loc },
+                loc,
+            });
+        }
         body.push({ kind: "return", value: ref, loc });
         lowerer.liftedFns.push({
             name,
@@ -3593,6 +3631,28 @@ function lowerClientHeadersOption(lowerer, node) {
     }
     return { kind: "call", callee: helper, args: [v], type: arrayOf(STRING), loc };
 }
+/** OutgoingMessage.addTrailers accepts an object or a pair-list literal.
+ * Flatten the latter in source order; non-literal nested arrays currently
+ * fence rather than reaching the C runtime with the wrong wire shape. */
+function lowerHttpTrailersOption(lowerer, node) {
+    if (!ts.isArrayLiteralExpression(node))
+        return lowerClientHeadersOption(lowerer, node);
+    const loc = locOf(node);
+    const flat = [];
+    for (const entry of node.elements) {
+        if (!ts.isArrayLiteralExpression(entry) || entry.elements.length !== 2) {
+            lowerer.noLowering("addTrailers pair list", entry, "use an object/Record or literal [name, value] pairs");
+        }
+        const pair = entry;
+        const name = pair.elements[0];
+        const value = pair.elements[1];
+        if (ts.isSpreadElement(name) || ts.isSpreadElement(value)) {
+            lowerer.noLowering("addTrailers pair with spread", entry, "use direct string name/value expressions");
+        }
+        flat.push(lowerer.lowerExprExpecting(name, STRING), lowerer.lowerExprExpecting(value, STRING));
+    }
+    return { kind: "arrayLit", elems: flat, type: arrayOf(STRING), loc };
+}
 /** Method calls on ClientRequest receivers: write/end/destroy and
  * on/once("response" | "error" | "timeout" | "close"). Null for other
  * receivers. */
@@ -3604,6 +3664,23 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
     const name = access.name.text;
     const loc = locOf(call);
     const args = call.arguments;
+    if (name === "flushHeaders" || name === "cork" || name === "uncork") {
+        requireStatementPosition(lowerer, call, `request.${name}()`);
+        if (args.length !== 0)
+            lowerer.noLowering(`request.${name} with arguments`, call, `${name}() takes no arguments`);
+        const receiver = coerceToHandle(lowerer, access.expression, HTTPCLIENTREQ_T);
+        const fn = name === "flushHeaders" ? "http.clientFlushHeaders"
+            : name === "cork" ? "http.clientCork" : "http.clientUncork";
+        return { kind: "libCall", fn, args: [receiver], type: VOID, loc };
+    }
+    if (name === "addTrailers") {
+        requireStatementPosition(lowerer, call, "request.addTrailers(...)");
+        if (args.length !== 1)
+            lowerer.noLowering("request.addTrailers argument count", call, "pass one trailer object or pair-list literal");
+        const receiver = coerceToHandle(lowerer, access.expression, HTTPCLIENTREQ_T);
+        const pairs = lowerHttpTrailersOption(lowerer, args[0]);
+        return { kind: "libCall", fn: "http.clientAddTrailers", args: [receiver, pairs], type: VOID, loc };
+    }
     if (name === "write" || name === "end") {
         requireStatementPosition(lowerer, call, `request.${name}(...)`);
         const minArgs = name === "write" ? 1 : 0;
@@ -3728,31 +3805,37 @@ export function lowerSocketInstanceOf(lowerer, expr, loc) {
 }
 /** True when `node` reads `.headers` off an IncomingMessage — the
  * receiver shape of both header-read forms. */
-function isHttpReqHeaders(lowerer, node) {
-    return (ts.isPropertyAccessExpression(node) &&
+function httpReqFieldCollection(lowerer, node) {
+    if (ts.isPropertyAccessExpression(node) &&
         !node.questionDotToken &&
-        node.name.text === "headers" &&
+        (node.name.text === "headers" || node.name.text === "trailers" ||
+            node.name.text === "headersDistinct" || node.name.text === "trailersDistinct") &&
         lowerer.mapTypeOf(lowerer.typeOf(node.expression))?.kind === "httpReq" &&
-        lowerer.isStdlibMember(node));
+        lowerer.isStdlibMember(node))
+        return node.name.text;
+    return null;
 }
 /** `req.headers["x-name"]` — the element twin of the property read below;
  * called from lowerElementAccess (the process.env precedent). Answers the
  * interned `string | undefined` union; names match case-insensitively
  * (the runtime stores them lowercased, like Node). */
 export function lowerHttpHeadersElement(lowerer, expr) {
-    if (!isHttpReqHeaders(lowerer, expr.expression))
+    const collection = httpReqFieldCollection(lowerer, expr.expression);
+    if (collection === null)
         return null;
     const recv = expr.expression.expression;
     const key = lowerer.lowerExpr(expr.argumentExpression);
     if (key.type.kind !== "string") {
-        lowerer.unsupported("SC1090", expr.argumentExpression, "indexing req.headers with non-string keys");
+        lowerer.unsupported("SC1090", expr.argumentExpression, `indexing req.${collection} with non-string keys`);
     }
     const receiver = lowerer.lowerExpr(recv);
     return {
         kind: "libCall",
-        fn: "http.reqHeader",
+        fn: collection === "headers" ? "http.reqHeader"
+            : collection === "trailers" ? "http.reqTrailer"
+                : collection === "headersDistinct" ? "http.reqHeaderValues" : "http.reqTrailerValues",
         args: [receiver, key],
-        type: lowerer.envValueType(),
+        type: collection.endsWith("Distinct") ? lowerer.withUndefinedArm(arrayOf(STRING)) : lowerer.envValueType(),
         loc: locOf(expr),
     };
 }
@@ -3848,6 +3931,26 @@ function lowerHttpResMethodCall(lowerer, call, access) {
     const name = access.name.text;
     const loc = locOf(call);
     const args = call.arguments;
+    if (name === "flushHeaders" || name === "cork" || name === "uncork") {
+        requireStatementPosition(lowerer, call, `res.${name}()`);
+        if (args.length !== 0)
+            lowerer.noLowering(`res.${name} with arguments`, call, `${name}() takes no arguments`);
+        const receiver = coerceToHandle(lowerer, access.expression, HTTPRES_T);
+        const fn = name === "flushHeaders" ? "http.resFlushHeaders"
+            : name === "cork" ? "http.resCork" : "http.resUncork";
+        return { kind: "libCall", fn, args: [receiver], type: VOID, loc };
+    }
+    if (name === "addTrailers") {
+        requireStatementPosition(lowerer, call, "res.addTrailers(...)");
+        if (lowerer.typeOf(access.expression).getSymbol()?.name === "Http2ServerResponse") {
+            lowerer.noLowering("Http2ServerResponse.addTrailers", call, "HTTP/2 response trailers are not supported by the static runtime yet");
+        }
+        if (args.length !== 1)
+            lowerer.noLowering("res.addTrailers argument count", call, "pass one trailer object or pair-list literal");
+        const receiver = coerceToHandle(lowerer, access.expression, HTTPRES_T);
+        const pairs = lowerHttpTrailersOption(lowerer, args[0]);
+        return { kind: "libCall", fn: "http.resAddTrailers", args: [receiver, pairs], type: VOID, loc };
+    }
     if (name === "setHeader") {
         requireStatementPosition(lowerer, call, "res.setHeader(...)");
         if (args.length !== 2) {