Fix EndOfLineComment

Author: FranzBusch

IntegrationTests/allocation-counter-tests-framework/template/scaffolding.swift

@@ -36,7 +36,8 @@ func waitForThreadsToQuiesce(shouldReachZero: Bool) {
             return
         }
         count += 1
-        usleep(shouldReachZero ? 50_000 : 200_000)  // allocs/frees happen on multiple threads, allow some cool down time
+        // allocs/frees happen on multiple threads, allow some cool down time
+        usleep(shouldReachZero ? 50_000 : 200_000)
         let newNumberOfUnfreed = getUnfreed()
         if oldNumberOfUnfreed == newNumberOfUnfreed && (!shouldReachZero || newNumberOfUnfreed <= 0) {
             // nothing happened in the last 100ms, let's assume everything's

Sources/NIOCore/ByteBuffer-aux.swift

@@ -480,7 +480,8 @@ extension ByteBuffer {
     /// - returns: A `ByteBuffer` sharing storage containing the readable bytes only.
     @inlinable
     public func slice() -> ByteBuffer {
-        self.getSlice(at: self.readerIndex, length: self.readableBytes)!  // must work, bytes definitely in the buffer// must work, bytes definitely in the buffer
+        // must work, bytes definitely in the buffer// must work, bytes definitely in the buffer
+        self.getSlice(at: self.readerIndex, length: self.readableBytes)!
     }
 
     /// Slice `length` bytes off this `ByteBuffer` and move the reader index forward by `length`.

Sources/NIOCore/Codec.swift

@@ -332,7 +332,8 @@ extension B2MDBuffer {
         } else {
             buffer.discardReadBytes()
             buffer.writeBuffers(self.buffers)
-            self.buffers.removeAll(keepingCapacity: self.buffers.capacity < 16)  // don't grow too much
+            // don't grow too much
+            self.buffers.removeAll(keepingCapacity: self.buffers.capacity < 16)
             self.buffers.append(buffer)
         }
     }
@@ -458,12 +459,15 @@ public final class ByteToMessageHandler<Decoder: ByteToMessageDecoder> {
         }
     }
 
-    internal private(set) var decoder: Decoder?  // only `nil` if we're already decoding (ie. we're re-entered)
+    // only `nil` if we're already decoding (ie. we're re-entered)
+    internal private(set) var decoder: Decoder?
     private let maximumBufferSize: Int?
-    private var queuedWrites = CircularBuffer<NIOAny>(initialCapacity: 1)  // queues writes received whilst we're already decoding (re-entrant write)
+    // queues writes received whilst we're already decoding (re-entrant write)
+    private var queuedWrites = CircularBuffer<NIOAny>(initialCapacity: 1)
     private var state: State = .active {
         willSet {
-            assert(!self.state.isFinalState, "illegal state on state set: \(self.state)")  // we can never leave final states
+            // we can never leave final states
+            assert(!self.state.isFinalState, "illegal state on state set: \(self.state)")
         }
     }
     private var removalState: RemovalState = .notAddedToPipeline
@@ -538,7 +542,8 @@ extension ByteToMessageHandler {
             var possiblyReclaimBytes = false
             var decoder: Decoder? = nil
             swap(&decoder, &self.decoder)
-            assert(decoder != nil)  // self.decoder only `nil` if we're being re-entered, but .available means we're not
+            // self.decoder only `nil` if we're being re-entered, but .available means we're not
+            assert(decoder != nil)
             defer {
                 swap(&decoder, &self.decoder)
                 if buffer.readableBytes > 0 && possiblyReclaimBytes {

Sources/NIOCore/EventLoopFuture.swift

@@ -767,7 +767,8 @@ extension EventLoopFuture {
 
     /// Add a callback.  If there's already a value, run as much of the chain as we can.
     @inlinable
-    @preconcurrency  // TODO: We want to remove @preconcurrency but it results in more allocations in 1000_udpconnections
+    // TODO: We want to remove @preconcurrency but it results in more allocations in 1000_udpconnections
+    @preconcurrency
     internal func _whenComplete(_ callback: @escaping @Sendable () -> CallbackList) {
         self._internalWhenComplete(callback)
     }

Sources/NIOPosix/BaseSocket.swift

@@ -247,7 +247,8 @@ class BaseSocket: BaseSocketProtocol {
         do {
             try self.ignoreSIGPIPE()
         } catch {
-            self.descriptor = NIOBSDSocket.invalidHandle  // We have to unset the fd here, otherwise we'll crash with "leaking open BaseSocket"
+            // We have to unset the fd here, otherwise we'll crash with "leaking open BaseSocket"
+            self.descriptor = NIOBSDSocket.invalidHandle
             throw error
         }
     }

Sources/NIOPosix/BaseSocketChannel.swift

@@ -77,28 +77,33 @@ private struct SocketChannelLifecycleManager {
         self.currentState == .closed
     }
 
-    @inline(__always)  // we need to return a closure here and to not suffer from a potential allocation for that this must be inlined
+    // we need to return a closure here and to not suffer from a potential allocation for that this must be inlined
+    @inline(__always)
     internal mutating func beginRegistration() -> ((EventLoopPromise<Void>?, ChannelPipeline) -> Void) {
         self.moveState(event: .beginRegistration)
     }
 
-    @inline(__always)  // we need to return a closure here and to not suffer from a potential allocation for that this must be inlined
+    // we need to return a closure here and to not suffer from a potential allocation for that this must be inlined
+    @inline(__always)
     internal mutating func finishRegistration() -> ((EventLoopPromise<Void>?, ChannelPipeline) -> Void) {
         self.moveState(event: .finishRegistration)
     }
 
-    @inline(__always)  // we need to return a closure here and to not suffer from a potential allocation for that this must be inlined
+    // we need to return a closure here and to not suffer from a potential allocation for that this must be inlined
+    @inline(__always)
     internal mutating func close() -> ((EventLoopPromise<Void>?, ChannelPipeline) -> Void) {
         self.moveState(event: .close)
     }
 
-    @inline(__always)  // we need to return a closure here and to not suffer from a potential allocation for that this must be inlined
+    // we need to return a closure here and to not suffer from a potential allocation for that this must be inlined
+    @inline(__always)
     internal mutating func activate() -> ((EventLoopPromise<Void>?, ChannelPipeline) -> Void) {
         self.moveState(event: .activate)
     }
 
     // MARK: private API
-    @inline(__always)  // we need to return a closure here and to not suffer from a potential allocation for that this must be inlined
+    // we need to return a closure here and to not suffer from a potential allocation for that this must be inlined
+    @inline(__always)
     private mutating func moveState(event: Event) -> ((EventLoopPromise<Void>?, ChannelPipeline) -> Void) {
         self.eventLoop.assertInEventLoop()
 
@@ -251,8 +256,10 @@ class BaseSocketChannel<SocketType: BaseSocketProtocol>: SelectableChannel, Chan
     private var inFlushNow: Bool = false  // Guard against re-entrance of flushNow() method.
     private var autoRead: Bool = true
 
-    // MARK: Variables that are really constants
-    private var _pipeline: ChannelPipeline! = nil  // this is really a constant (set in .init) but needs `self` to be constructed and therefore a `var`. Do not change as this needs to accessed from arbitrary threads
+    // MARK: Variables that are really constant
+    // this is really a constant (set in .init) but needs `self` to be constructed and
+    // therefore a `var`. Do not change as this needs to accessed from arbitrary threads
+    private var _pipeline: ChannelPipeline! = nil
 
     // MARK: Special variables, please read comments.
     // For reads guarded by _either_ `self._offEventLoopLock` or the EL thread

Sources/NIOPosix/LinuxUring.swift

@@ -44,7 +44,8 @@ extension TimeAmount {
 // for the type of event issued (poll/modify/delete).
 @usableFromInline struct URingUserData {
     @usableFromInline var fileDescriptor: CInt
-    @usableFromInline var registrationID: UInt16  // SelectorRegistrationID truncated, only have room for bottom 16 bits (could be expanded to 24 if required)
+    // SelectorRegistrationID truncated, only have room for bottom 16 bits (could be expanded to 24 if required)
+    @usableFromInline var registrationID: UInt16
     @usableFromInline var eventType: CQEEventType
     @usableFromInline var padding: Int8  // reserved for future use
 
@@ -112,7 +113,8 @@ final internal class URing {
     internal static let POLLERR: CUnsignedInt = numericCast(CNIOLinux.POLLERR)
     internal static let POLLRDHUP: CUnsignedInt = CNIOLinux_POLLRDHUP()  // numericCast(CNIOLinux.POLLRDHUP)
     internal static let POLLHUP: CUnsignedInt = numericCast(CNIOLinux.POLLHUP)
-    internal static let POLLCANCEL: CUnsignedInt = 0xF000_0000  // Poll cancelled, need to reregister for singleshot polls
+    // Poll cancelled, need to reregister for singleshot polls
+    internal static let POLLCANCEL: CUnsignedInt = 0xF000_0000
 
     private var ring = io_uring()
     private let ringEntries: CUnsignedInt = 8192
@@ -276,10 +278,12 @@ final internal class URing {
 
         self.withSQE { sqe in
             CNIOLinux.io_uring_prep_poll_add(sqe, fileDescriptor, pollMask)
-            CNIOLinux.io_uring_sqe_set_data(sqe, bitpatternAsPointer)  // must be done after prep_poll_add, otherwise zeroed out.
+            // must be done after prep_poll_add, otherwise zeroed out.
+            CNIOLinux.io_uring_sqe_set_data(sqe, bitpatternAsPointer)
 
             if multishot {
-                sqe!.pointee.len |= IORING_POLL_ADD_MULTI  // turn on multishots, set through environment variable
+                // turn on multishots, set through environment variable
+                sqe!.pointee.len |= IORING_POLL_ADD_MULTI
             }
         }
 
@@ -316,7 +320,8 @@ final internal class URing {
 
         self.withSQE { sqe in
             CNIOLinux.io_uring_prep_poll_remove(sqe, .init(userData: bitPattern))
-            CNIOLinux.io_uring_sqe_set_data(sqe, .init(userData: userbitPattern))  // must be done after prep_poll_add, otherwise zeroed out.
+            // must be done after prep_poll_add, otherwise zeroed out.
+            CNIOLinux.io_uring_sqe_set_data(sqe, .init(userData: userbitPattern))
 
             if link {
                 CNIOLinux_io_uring_set_link_flag(sqe)

Sources/NIOPosix/SelectableEventLoop.swift

@@ -133,8 +133,10 @@ internal final class SelectableEventLoop: EventLoop {
         )
         return self._externalStateLock
     }
-    private var internalState: InternalState = .runningAndAcceptingNewRegistrations  // protected by the EventLoop thread
-    private var externalState: ExternalState = .open  // protected by externalStateLock
+    // protected by the EventLoop thread
+    private var internalState: InternalState = .runningAndAcceptingNewRegistrations
+    // protected by externalStateLock
+    private var externalState: ExternalState = .open
 
     let bufferPool: Pool<PooledBuffer>
     let msgBufferPool: Pool<PooledMsgBuffer>

Sources/NIOPosix/SelectorKqueue.swift

@@ -71,7 +71,8 @@ extension KQueueEventFilterSet {
         // we only use three filters (EVFILT_READ, EVFILT_WRITE and EVFILT_EXCEPT) so the number of changes would be 3.
         var kevents = KeventTriple()
 
-        let differences = previousKQueueFilterSet.symmetricDifference(self)  // contains all the events that need a change (either need to be added or removed)
+        // contains all the events that need a change (either need to be added or removed)
+        let differences = previousKQueueFilterSet.symmetricDifference(self)
 
         func calculateKQueueChange(event: KQueueEventFilterSet) -> UInt16? {
             guard differences.contains(event) else {

Sources/NIOPosix/SelectorUring.swift

@@ -349,7 +349,9 @@ extension Selector: _SelectorBackendProtocol {
                     // This is only needed due to the edge triggered nature of liburing, possibly
                     // we can get away with only updating (force triggering an event if available) for
                     // partial reads (where we currently give up after N iterations)
-                    if multishot && self.shouldRefreshPollForEvent(selectorEvent: selectorEvent) {  // can be after guard as it is multishot
+
+                    // can be after guard as it is multishot
+                    if multishot && self.shouldRefreshPollForEvent(selectorEvent: selectorEvent) {
                         ring.io_uring_poll_update(
                             fileDescriptor: event.fd,
                             newPollmask: registration.interested.uringEventSet,

Sources/NIOPosix/System.swift

@@ -96,7 +96,8 @@ func sysRecvFrom_wrapper(
     src_addr: UnsafeMutablePointer<sockaddr>,
     addrlen: UnsafeMutablePointer<socklen_t>
 ) -> CLong {
-    recvfrom(sockfd, buf, len, flags, src_addr, addrlen)  // src_addr is 'UnsafeMutablePointer', but it need to be 'UnsafePointer'
+    // src_addr is 'UnsafeMutablePointer', but it need to be 'UnsafePointer'
+    recvfrom(sockfd, buf, len, flags, src_addr, addrlen)
     // src_addr is 'UnsafeMutablePointer', but it need to be 'UnsafePointer'
 }
 func sysWritev_wrapper(fd: CInt, iov: UnsafePointer<iovec>?, iovcnt: CInt) -> CLong {

Sources/NIOTLS/SNIHandler.swift

@@ -169,7 +169,9 @@ public final class SNIHandler: ByteToMessageDecoder {
         //
         // From this point onwards if we don't have enough data to satisfy a read, this is an error and
         // we will fall back to let the upper layers handle it.
-        tempBuffer = tempBuffer.getSlice(at: tempBuffer.readerIndex, length: Int(contentLength))!  // length check above
+
+        // length check above
+        tempBuffer = tempBuffer.getSlice(at: tempBuffer.readerIndex, length: Int(contentLength))!
 
         // Now parse the handshake header. If the length of the handshake message is not exactly the
         // length of this record, something has gone wrong and we should give up.

Tests/NIOCoreTests/ByteBufferTest.swift

@@ -2345,7 +2345,8 @@ class ByteBufferTest: XCTestCase {
             XCTAssertNotEqual(buf.capacity, oldCapacity)
             XCTAssertNotEqual(oldPtrVal, newPtrVal)
         }
-        bufCopy.writeString("foo")  // stops the optimiser removing `bufCopy` which would make `reserveCapacity` use malloc instead of realloc
+        // stops the optimiser removing `bufCopy` which would make `reserveCapacity` use malloc instead of realloc
+        bufCopy.writeString("foo")
     }
 
     func testReserveCapacityWithMinimumWritableBytesWhenNotEnoughWritableBytes() {

Tests/NIOHTTP1Tests/HTTPDecoderTest.swift

@@ -209,8 +209,9 @@ class HTTPDecoderTest: XCTestCase {
             "OPTIONS * HTTP/1.1\r\nHost: localhost\r\nUpgrade: myproto\r\nConnection: upgrade\r\n\r\nXXXX"
         )
 
+        // allow the event loop to run (removal is not synchronous here)
         XCTAssertNoThrow(try channel.writeInbound(buffer))
-        (channel.eventLoop as! EmbeddedEventLoop).run()  // allow the event loop to run (removal is not synchronous here)
+        (channel.eventLoop as! EmbeddedEventLoop).run()
         XCTAssertNoThrow(
             try channel.pipeline.assertDoesNotContain(handlerType: ByteToMessageHandler<HTTPRequestDecoder>.self)
         )
@@ -267,7 +268,8 @@ class HTTPDecoderTest: XCTestCase {
         )
         XCTAssertNoThrow(try channel.pipeline.addHandler(Receiver()).wait())
 
-        // This connect call is semantically wrong, but it's how you active embedded channels properly right now.
+        // This connect call is semantically wrong, but it's how you
+        // active embedded channels properly right now.
         XCTAssertNoThrow(try channel.connect(to: SocketAddress(ipAddress: "127.0.0.1", port: 8888)).wait())
 
         var buffer = channel.allocator.buffer(capacity: 64)
@@ -276,7 +278,8 @@ class HTTPDecoderTest: XCTestCase {
         )
 
         XCTAssertNoThrow(try channel.writeInbound(buffer))
-        (channel.eventLoop as! EmbeddedEventLoop).run()  // allow the event loop to run (removal is not synchrnous here)
+        // allow the event loop to run (removal is not synchrnous here)
+        (channel.eventLoop as! EmbeddedEventLoop).run()
         XCTAssertNoThrow(
             try channel.pipeline.assertDoesNotContain(handlerType: ByteToMessageHandler<HTTPRequestDecoder>.self)
         )
@@ -348,7 +351,8 @@ class HTTPDecoderTest: XCTestCase {
         )
 
         XCTAssertNoThrow(try channel.writeInbound(buffer))
-        (channel.eventLoop as! EmbeddedEventLoop).run()  // allow the event loop to run (removal is not synchrnous here)
+        // allow the event loop to run (removal is not synchronous here)
+        (channel.eventLoop as! EmbeddedEventLoop).run()
         XCTAssertNoThrow(
             try channel.pipeline.assertDoesNotContain(handlerType: ByteToMessageHandler<HTTPRequestDecoder>.self)
         )

Tests/NIOPosixTests/ChannelPipelineTest.swift

@@ -1533,20 +1533,24 @@ class ChannelPipelineTest: XCTestCase {
         // And now close
         operations.close(promise: nil)
 
+        // EmbeddedChannel itself does one, we did the other.
         XCTAssertEqual(eventCounter.bindCalls, 1)
         XCTAssertEqual(eventCounter.channelActiveCalls, 2)
-        XCTAssertEqual(eventCounter.channelInactiveCalls, 2)  // EmbeddedChannel itself does one, we did the other.
+        XCTAssertEqual(eventCounter.channelInactiveCalls, 2)
         XCTAssertEqual(eventCounter.channelReadCalls, 1)
         XCTAssertEqual(eventCounter.channelReadCompleteCalls, 1)
-        XCTAssertEqual(eventCounter.channelRegisteredCalls, 3)  // EmbeddedChannel itself does one, we did the other two.
-        XCTAssertEqual(eventCounter.channelUnregisteredCalls, 2)  // EmbeddedChannel itself does one, we did the other.
+        // EmbeddedChannel itself does one, we did the other two.
+        XCTAssertEqual(eventCounter.channelRegisteredCalls, 3)
+        // EmbeddedChannel itself does one, we did the other.
+        XCTAssertEqual(eventCounter.channelUnregisteredCalls, 2)
         XCTAssertEqual(eventCounter.channelWritabilityChangedCalls, 1)
         XCTAssertEqual(eventCounter.closeCalls, 1)
         XCTAssertEqual(eventCounter.connectCalls, 1)
         XCTAssertEqual(eventCounter.errorCaughtCalls, 1)
         XCTAssertEqual(eventCounter.flushCalls, 2)  // flush, and writeAndFlush
         XCTAssertEqual(eventCounter.readCalls, 1)
-        XCTAssertEqual(eventCounter.registerCalls, 2)  // EmbeddedChannel itself does one, we did the other.
+        // EmbeddedChannel itself does one, we did the other.
+        XCTAssertEqual(eventCounter.registerCalls, 2)
         XCTAssertEqual(eventCounter.triggerUserOutboundEventCalls, 1)
         XCTAssertEqual(eventCounter.userInboundEventTriggeredCalls, 1)
         XCTAssertEqual(eventCounter.writeCalls, 2)  // write, and writeAndFlush

Tests/NIOPosixTests/CodecTest.swift

@@ -1408,7 +1408,8 @@ public final class ByteToMessageDecoderTest: XCTestCase {
         }
         XCTAssertNoThrow(XCTAssertNil(try channel.readInbound()))
 
-        XCTAssertNoThrow(try channel.writeInbound(buffer))  // this will go through because the decoder is already 'done'
+        // this will go through because the decoder is already 'done'
+        XCTAssertNoThrow(try channel.writeInbound(buffer))
     }
 
     func testBasicLifecycle() {

Tests/NIOPosixTests/EventLoopMetricsDelegateTests.swift

@@ -63,7 +63,8 @@ final class EventLoopMetricsDelegateTests: XCTestCase {
             }
             if let lastTickStartTime = delegate.infos.last?.startTime {
                 let timeSinceStart = lastTickStartTime - testStartTime
-                XCTAssertLessThan(timeSinceStart.nanoseconds, 100_000_000)  // This should be near instant, limiting to 100ms
+                // This should be near instant, limiting to 100ms
+                XCTAssertLessThan(timeSinceStart.nanoseconds, 100_000_000)
                 XCTAssertGreaterThan(timeSinceStart.nanoseconds, 0)
             }
         }