test(owned-api): cover Socket.Accept and TcpListener.AcceptSocket branches

CodeRabbit: the accept matcher has three hard-coded branches but only
AcceptTcpClient had an end-to-end fixture, so a typo/regression in the
Socket.Accept or TcpListener.AcceptSocket branch would slip the corpus
benchmark (its after.cs specificity check + recall visibility).

Add a corpus fixture for each: socket-accept-leak (Socket.Accept) and
tcplistener-acceptsocket-leak (TcpListener.AcceptSocket) — before.cs leaks the
accepted socket (OWN001), after.cs disposes it with `using` (clean), case.own
reduces the pattern. case.own -> OWN001 locally (test_corpus 24/24); before/after
verified by the CI corpus benchmark.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019846YSZ35c7CdkWQ1qX5gm

Author: claude

corpus/real-world/socket-accept-leak/after.cs

@@ -0,0 +1,10 @@
+using System.Net.Sockets;
+
+static class SocketAcceptLeak
+{
+    static bool Serve(Socket listener)
+    {
+        using var conn = listener.Accept();   // disposed at scope exit -> clean
+        return conn.Connected;
+    }
+}

corpus/real-world/socket-accept-leak/before.cs

@@ -0,0 +1,13 @@
+using System.Net.Sockets;
+
+// A Socket returned by Socket.Accept() is a fresh owned IDisposable the caller must dispose;
+// dropping it leaks the accepted connection (handle held until finalization). The listening
+// socket is a borrowed parameter, so the ONLY leak is `conn`.
+static class SocketAcceptLeak
+{
+    static bool Serve(Socket listener)
+    {
+        var conn = listener.Accept();   // fresh owned Socket -> OWN001 (never disposed)
+        return conn.Connected;           // used, but never disposed -> leak
+    }
+}

corpus/real-world/socket-accept-leak/case.own

@@ -0,0 +1,15 @@
+// OwnLang model of the Socket.Accept() accept-loop leak (owned-API tranche). The accepted Socket
+// is a fresh owned IDisposable, used and never released -> OWN001. See notes.md.
+module Corpus
+resource Conn {
+  acquire accept
+  release dispose
+  kind "disposable"
+  emit_type    "Socket"
+  emit_acquire "{args}.Accept()"
+  emit_release "{0}.Dispose()"
+}
+fn Serve(listener: int) {
+  let conn = acquire Conn(listener);   // var conn = listener.Accept()
+  // conn used (conn.Connected); no `release conn;` -> OWN001
+}

corpus/real-world/socket-accept-leak/expected-diagnostics.txt

@@ -0,0 +1 @@
+OWN001

corpus/real-world/socket-accept-leak/notes.md

@@ -0,0 +1,8 @@
+# socket-accept-leak
+
+`Socket.Accept()` returns a fresh **owned** `Socket` the caller must dispose; dropping it leaks the
+accepted connection. Covers the `Socket.Accept` branch of the accept-loop owned-API rule (sibling
+to `tcplistener-accept-leak`).
+
+- **before.cs** — `var conn = listener.Accept();` used and never disposed → `OWN001`.
+- **after.cs** — `using var conn = …` → clean.

corpus/real-world/tcplistener-acceptsocket-leak/after.cs

@@ -0,0 +1,10 @@
+using System.Net.Sockets;
+
+static class AcceptSocketLeak
+{
+    static bool Serve(TcpListener listener)
+    {
+        using var sock = listener.AcceptSocket();   // disposed at scope exit -> clean
+        return sock.Connected;
+    }
+}

corpus/real-world/tcplistener-acceptsocket-leak/before.cs

@@ -0,0 +1,13 @@
+using System.Net.Sockets;
+
+// A Socket returned by TcpListener.AcceptSocket() is a fresh owned IDisposable the caller must
+// dispose; dropping it leaks the accepted connection. The listener is a borrowed parameter, so the
+// ONLY leak is `sock`.
+static class AcceptSocketLeak
+{
+    static bool Serve(TcpListener listener)
+    {
+        var sock = listener.AcceptSocket();   // fresh owned Socket -> OWN001 (never disposed)
+        return sock.Connected;                 // used, but never disposed -> leak
+    }
+}

corpus/real-world/tcplistener-acceptsocket-leak/case.own

@@ -0,0 +1,15 @@
+// OwnLang model of the TcpListener.AcceptSocket() accept-loop leak (owned-API tranche). The
+// accepted Socket is a fresh owned IDisposable, used and never released -> OWN001. See notes.md.
+module Corpus
+resource Sock {
+  acquire accept
+  release dispose
+  kind "disposable"
+  emit_type    "Socket"
+  emit_acquire "{args}.AcceptSocket()"
+  emit_release "{0}.Dispose()"
+}
+fn Serve(listener: int) {
+  let sock = acquire Sock(listener);   // var sock = listener.AcceptSocket()
+  // sock used (sock.Connected); no `release sock;` -> OWN001
+}

corpus/real-world/tcplistener-acceptsocket-leak/expected-diagnostics.txt

@@ -0,0 +1 @@
+OWN001

corpus/real-world/tcplistener-acceptsocket-leak/notes.md

@@ -0,0 +1,8 @@
+# tcplistener-acceptsocket-leak
+
+`TcpListener.AcceptSocket()` returns a fresh **owned** `Socket` the caller must dispose; dropping it
+leaks the accepted connection. Covers the `TcpListener.AcceptSocket` branch of the accept-loop
+owned-API rule (sibling to `tcplistener-accept-leak`, which covers `AcceptTcpClient`).
+
+- **before.cs** — `var sock = listener.AcceptSocket();` used and never disposed → `OWN001`.
+- **after.cs** — `using var sock = …` → clean.