[tannevaled]

socket: open with a block must close, which is 27 of the hangs in #916

TCPSocket.open, TCPServer.open and Socket.open were bare aliases for
.new, so the block form closed nothing: the socket outlived the block and the
peer waited for an EOF that never came.

⛔ That is the whole net-http column of issue 916

library/net-http/http/fixtures/http_server.rb serves one client at a time
and shuts down by opening a new connection to write an unterminated "CLOSE":

def close
  TCPSocket.open(ip, port) { |socket| socket.write "CLOSE" }
  @thread.join
end

With that socket still open the server's gets("\r\n\r\n") never returns, the
listen loop never comes back round to accept, and @thread.join never
completes. Every one of the 27 library/net-http files ends on that join.

Measured, against the restored MRI oracle

The ten-line reproduction, before:

	MRI 4.0.6	rbgo
closed? after the block	true	false
the peer's gets	"CLOSE"	blocks for ever
join	:joined	hangs

After this change rbgo prints the same seven lines as MRI, in the same order,
and exits 0.

And over library/net-http + library/socket + library/timeout, 321 files,
30 s each:

	files killed under rbgo	passing
before	36	243
after	9	274

27 hangs gone, +31 examples. The nine that remain are the other two columns
of that issue, untouched here: library/socket ×8 and library/timeout ×1.
(net-http/http/start_spec.rb is now killed on the control — MRI hangs on
it and rbgo passes 12 — so the net-http column is 27 → 0.)

⛔ It is not the GVL, which is what I expected to find

A goroutine dump of a hung get_spec.rb puts the server thread correctly
inside ioBlock with the GVL released (readUntil → bufio.ReadByte →
net.(*conn).Read) and the main thread in threadJoin. The emulated GVL
behaves; the socket was simply still open.

Nor does Net::HTTP leak its own connection — my first guess, and wrong: the
reproduction shows peer closed (gets returned nil) after the request under
both engines.

How it closes, and why there is no fourth spelling of close

It sends the class's own close method, so TCPSocket, TCPServer and
Socket each keep the single close they already had. Each is guarded by
s.closed and therefore idempotent, so a block that closed the socket itself
is not closed twice. The close runs in a defer, so an exception or a break
leaves it closed too: this is an ensure, not a tidy-up on the happy path.

The test fails rather than hangs

It asserts the contract on the socket the block was handed, not through a
peer: the block's value comes back (not the socket), closed? is true after a
normal return and after an exception, and open without a block still gives
an open socket exactly as .new does. A regression therefore fails this test
instead of hanging it.

Refs #931, #916

(Both stay open: #931 also asks for an audit of the same block form on
UNIXSocket and UDPSocket, and for gets(sep) returning partial data at EOF,
neither of which this change settles; #916 still has nine hangs left.)

🤖 Generated with Claude Code