@scriptc/compiler 0.3.2 → 0.3.3

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

@@ -1476,6 +1476,18 @@ function lowerNetServerMethodCall(lowerer, call, access) {
             loc,
         };
     }
+    if ((name === "ref" || name === "unref") && args.length === 0) {
+        // Whether the server keeps the event loop alive.
+        requireStatementPosition(lowerer, call, `server.${name}()`);
+        const receiver = coerceToHandle(lowerer, access.expression, NETSERVER_T);
+        return {
+            kind: "libCall",
+            fn: "net.serverSetRef",
+            args: [receiver, boolLit(name === "ref", loc)],
+            type: VOID,
+            loc,
+        };
+    }
     if (name === "address") {
         // The full AddressInfo record (the dgram.address materialization).
         // The composed `server.address().port` read already lowered through
@@ -1504,14 +1516,26 @@ function lowerNetSocketMethodCall(lowerer, call, access) {
     const name = access.name.text;
     const loc = locOf(call);
     const args = call.arguments;
+    if ((name === "ref" || name === "unref") && args.length === 0) {
+        // Whether the socket keeps the event loop alive.
+        requireStatementPosition(lowerer, call, `socket.${name}()`);
+        const receiver = lowerer.lowerExpr(access.expression);
+        return {
+            kind: "libCall",
+            fn: "net.sockSetRef",
+            args: [receiver, boolLit(name === "ref", loc)],
+            type: VOID,
+            loc,
+        };
+    }
     if (name === "write" || name === "end") {
         requireStatementPosition(lowerer, call, `socket.${name}(...)`);
         // write(chunk, encoding) — the two-argument encoding form: 'buffer'
-        // beside a string chunk is Node's stream_base typecheck ("Second
-        // argument must be a buffer", thrown synchronously on an established
-        // socket — the invalid-input probes' shape); utf8 spellings are the
-        // plain write (that IS the encoding written); a Buffer chunk ignores
-        // the encoding like Node does. Other encodings keep the fence.
+        // beside a string chunk is Writable's encoding check (a synchronous
+        // ERR_UNKNOWN_ENCODING TypeError, "Unknown encoding: buffer" — the
+        // invalid-input probes' shape); utf8 spellings are the plain write
+        // (that IS the encoding written); a Buffer chunk ignores the encoding
+        // like Node does. Other encodings keep the fence.
         if (name === "write" && args.length === 2) {
             const encT = lowerer.typeOf(args[1]);
             const chunkT = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
@@ -1520,7 +1544,7 @@ function lowerNetSocketMethodCall(lowerer, call, access) {
                     chunkT.kind === "string" &&
                     isJsSourceFile(call.getSourceFile())) {
                     lowerer.lowerExpr(args[0]); // evaluation order (effect-free in practice)
-                    return nodeThrowExpr(1, "ERR_INVALID_ARG_TYPE", "Second argument must be a buffer", VOID, loc);
+                    return nodeThrowExpr(1, "ERR_UNKNOWN_ENCODING", "Unknown encoding: buffer", VOID, loc);
                 }
                 const passthrough = (chunkT.kind === "string" && (encT.value === "utf8" || encT.value === "utf-8")) ||
                     (chunkT.kind === "bytes" && chunkT.elem === "u8");
@@ -2694,7 +2718,7 @@ function lowerHttpServerOptions(lowerer, node, what) {
         }
         if (key === "joinDuplicateHeaders") {
             // Literal true/false: the flag decides parse-time read semantics,
-            // so a runtime value would silently pick one — fence dynamics.
+            // so a runtime value would pick one without a diagnostic — fence dynamics.
             if (initializer !== null && initializer.kind === ts.SyntaxKind.TrueKeyword) {
                 joinDup = true;
                 continue;
@@ -4313,7 +4337,7 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
     }
     if (connCb !== null && (host !== null || port !== null)) {
         // Node would use host/port only for the Host header once a dialer
-        // exists — a silent half-use; set headers.host instead.
+        // exists — a partial use with no warning; set headers.host instead.
         lowerer.noLowering(`${member} mixing createConnection with hostname/host/port`, optsNode, "the dialer supplies the socket — set the Host header via headers: { host: ... } instead");
     }
     if (agentVal !== null && connCb !== null) {
@@ -4834,7 +4858,7 @@ function lowerHttpReqMethodCall(lowerer, call, access) {
     }
     if (name === "setEncoding") {
         // setEncoding('utf8') — 'data' delivers strings (the chunk-encoding
-        // window); other real encodings fence loudly at runtime, unknown
+        // window); other real encodings throw "not supported yet" at runtime, unknown
         // names throw Node's ERR_UNKNOWN_ENCODING.
         requireStatementPosition(lowerer, call, "req.setEncoding(...)");
         if (args.length !== 1) {
@@ -5127,7 +5151,8 @@ function lowerHttpResMethodCall(lowerer, call, access) {
             if (v.type.kind === "dyn") {
                 // A checked-dynamic headers value (an untyped JS helper's
                 // parameter — the suite's test(headers) idiom): the runtime OBJ
-                // walk sets each entry, loud fences for non-string/number values.
+                // walk sets each entry and throws ERR_INVALID_ARG_TYPE for
+                // non-string/number values.
                 return headResult("http.resWriteHeadDyn", [receiver, status, v]);
             }
             if (v.type.kind !== "record") {
@@ -5173,9 +5198,9 @@ function lowerHttpResMethodCall(lowerer, call, access) {
         }
         const receiver = coerceToHandle(lowerer, access.expression, HTTPRES_T);
         // end's callback forms — end(cb) / end(data, cb): the callback fires
-        // deferred once the body went out (Node's 'finish' emit), through
-        // the resOnFinish slot registered just before the end call in an
-        // interned composing helper.
+        // deferred once the body went out (just before Node's 'finish' emit),
+        // through the resOnEndCallback slot registered just before the end
+        // call in an interned composing helper.
         let cbArg = null;
         let dataNode = args[0];
         if (name === "end" && args.length === 2) {
@@ -5218,7 +5243,7 @@ function lowerHttpResMethodCall(lowerer, call, access) {
                             kind: "exprStmt",
                             expr: {
                                 kind: "libCall",
-                                fn: "http.resOnFinish",
+                                fn: "http.resOnEndCallback",
                                 args: [
                                     varRef(params[0].localId, params[0].type, loc),
                                     varRef(params[all.length - 1].localId, params[all.length - 1].type, loc),