net: report BoundSocket connect errors asynchronously

Keep the synchronous connect(2) issuance for adopted BoundSockets (so the
concrete source address is observable via localAddress once connect()
returns), but deliver connection failures through the normal deferred
'error' event on all platforms instead of throwing synchronously. This
gives a single, consistent error channel across POSIX and Windows, where
connect(2) is asynchronous (ConnectEx).

Author: guybedford

doc/api/net.md

@@ -1658,8 +1658,9 @@ throw [`ERR_SOCKET_HANDLE_ADOPTED`][]. A handle that is never adopted must be
 closed to avoid leaking the socket.
 
 When an adopted `BoundSocket` connects to a numeric IP literal, `connect(2)` is
-issued synchronously: [`socket.localAddress`][] is resolved once
-[`socket.connect()`][] returns, and on POSIX failures throw synchronously.
+issued synchronously, so [`socket.localAddress`][] is resolved once
+[`socket.connect()`][] returns. Connection failures are still reported via a
+deferred `'error'` event.
 
 ```mjs
 import net from 'node:net';

lib/net.js

@@ -1249,7 +1249,7 @@ function checkBindError(err, port, handle) {
 
 
 function internalConnect(
-  self, address, port, addressType, localAddress, localPort, flags, boundSocket) {
+  self, address, port, addressType, localAddress, localPort, flags) {
   // TODO return promise from Socket.prototype.connect which
   // wraps _connectReq.
 
@@ -1313,12 +1313,6 @@ function internalConnect(
     }
 
     const ex = new ExceptionWithHostPort(err, 'connect', address, port, details);
-    // Synchronous connect(2): throw in-tick instead of a deferred 'error'.
-    if (boundSocket) {
-      self.connecting = false;
-      self.destroy();
-      throw ex;
-    }
     self.destroy(ex);
   } else if ((addressType === 6 || addressType === 4) && hasObserver('net')) {
     startPerf(self, kPerfHooksNetConnectContext, { type: 'net', name: 'connect', detail: { host: address, port } });
@@ -1574,12 +1568,13 @@ function lookupAndConnect(self, options) {
   const addressType = isIP(host);
   if (addressType) {
     // An adopted BoundSocket needs no lookup: issue connect(2) in-tick so the
-    // concrete source address resolves and failures throw synchronously.
+    // kernel-resolved concrete source address is observable synchronously.
+    // Connection failures are still reported via a deferred 'error' event.
     if (self[kBoundSource]) {
       defaultTriggerAsyncIdScope(
         self[async_id_symbol],
         internalConnect,
-        self, host, port, addressType, localAddress, localPort, 0, true,
+        self, host, port, addressType, localAddress, localPort,
       );
       return;
     }

test/parallel/test-net-boundsocket.js

@@ -202,18 +202,16 @@ if (!common.isWindows && process.getuid() !== 0) {
   }));
 }
 
-// A synchronous connect(2) failure throws in-tick, without an 'error' event.
-// An IPv4-bound handle connecting to an IPv6 literal fails on family mismatch.
-// POSIX-only: on Windows connect(2) is asynchronous (ConnectEx), so the error
-// is deferred rather than thrown.
-if (!common.isWindows) {
+// A connect failure is reported via a deferred 'error' event, never thrown
+// synchronously. An IPv4-bound handle connecting to an IPv6 literal fails on
+// address family mismatch.
+{
   const bound = new net.BoundSocket({ host: '127.0.0.1', port: 0 });
   const client = new net.Socket({ handle: bound });
-  client.on('error', common.mustNotCall());
-  assert.throws(() => {
-    client.connect({ host: '::1', port: 1 });
-  }, { syscall: 'connect' });
-  assert.strictEqual(client.destroyed, true);
+  client.connect({ host: '::1', port: 1 });
+  client.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.syscall, 'connect');
+  }));
 }
 
 // reusePort: SO_REUSEPORT permits multiple listeners on the same port. Support