[varun06]

Motivation and Context

• NetworkTransport.attemptConnection() set connection.stateUpdateHandler on the
  actor's executor but cleared it from AsyncStream's onTermination, which can run on
  any thread. The handler is now cleared with defer on the actor after the for await
  loop exits.
• The test double MockNetworkConnection was @unchecked Sendable with unprotected
  mutable state accessed from both the transport actor and @MainActor tasks. Its state
  is now lock-protected, and handlers are snapshotted before being invoked.

Related upstream work in the same area: #283, #216, #213.

How Has This Been Tested?

swift test passes. (A TSan run of NetworkTransportTests currently aborts on main in Heartbeat parsing — a misaligned load(as: UInt64.self) — which is unrelated to this change.)

Breaking Changes

None.

Types of changes

• Bug fix (non-breaking change which fixes an issue)

[andreyvelich]

@varun06 This removes a queued item before the cancelled/error checks, so it gets dropped on those paths. isLast is also read under a separate lock. Do both under one lock:

Suggested change

	let (state, error, data): (NWConnection.State, Swift.Error?, Data?) = lock.withLock {
	let d = dataToReceive.isEmpty ? nil : dataToReceive.removeFirst()
	return (mockState, mockError, d)
	}
	let data = self.dataToReceive.removeFirst()
	completion(data, nil, self.dataToReceive.isEmpty, nil)
	if state == .cancelled {
	completion(nil, nil, true, NWError.posix(POSIXErrorCode.ECANCELED))
	return
	}
	if let error {
	completion(nil, nil, false, error as? NWError)
	return
	}
	let isLast = lock.withLock { dataToReceive.isEmpty }
	completion(data ?? Data(), nil, data == nil ? false : isLast, nil)
	let (state, error, data, isLast): (NWConnection.State, Swift.Error?, Data?, Bool) =
	lock.withLock {
	guard mockState != .cancelled, mockError == nil, !dataToReceive.isEmpty else {
	return (mockState, mockError, nil, false)
	}
	let data = dataToReceive.removeFirst()
	return (mockState, mockError, data, dataToReceive.isEmpty)
	}
	if state == .cancelled {
	completion(nil, nil, true, NWError.posix(POSIXErrorCode.ECANCELED))
	return
	}
	if let error {
	completion(nil, nil, false, error as? NWError)
	return
	}
	completion(data ?? Data(), nil, isLast, nil)

[varun06]

Good catch on both — applied your suggestion in 419a7b6. State checks, the dequeue, and isLast now happen under a single lock, so a queued item is no longer dropped on the cancelled/error paths. Full test suite passes locally. Thanks!

[akhilcb]

Thanks @varun06. 419a7b6 fixes the mock receive path. The cancelled and error checks, the dequeue and the isLast read now all happen under one lock, so a queued item can't be dropped on the cancelled or error paths anymore. CI is green across macOS, Linux and conformance. LGTM.