     var eventLoop: EventLoop { get }
 }
 
-/// Default implementations for `ChannelOutboundInvoker` methods. Each method that returns a `EventLoopFuture` will just do the following:
+/// Extra `ChannelOutboundInvoker` methods. Each method that returns a `EventLoopFuture` will just do the following:
 ///     - create a new `EventLoopPromise<Void>`
 ///     - call the corresponding method that takes a `EventLoopPromise<Void>`
 ///     - return `EventLoopPromise.futureResult`
 extension ChannelOutboundInvoker {
-    public func register() -> EventLoopFuture<Void> {
-        let promise = makePromise()
+
+    /// Register on an `EventLoop` and so have all its IO handled.
+    ///
+    /// - returns: the future which will be notified once the operation completes.
+    public func register(file: StaticString = #file, line: UInt = #line) -> EventLoopFuture<Void> {
+        let promise = makePromise(file: file, line: line)
         register(promise: promise)
         return promise.futureResult
     }
 
-    public func bind(to address: SocketAddress) -> EventLoopFuture<Void> {
-        let promise = makePromise()
+    /// Bind to a `SocketAddress`.
+    /// - parameters:
+    ///       - to: the `SocketAddress` to which we should bind the `Channel`.
+    /// - returns: the future which will be notified once the operation completes.
+    public func bind(to address: SocketAddress, file: StaticString = #file, line: UInt = #line) -> EventLoopFuture<Void> {
+        let promise = makePromise(file: file, line: line)
         bind(to: address, promise: promise)
         return promise.futureResult
     }
 
-    public func connect(to address: SocketAddress) -> EventLoopFuture<Void> {
-        let promise = makePromise()
+    /// Connect to a `SocketAddress`.
+    /// - parameters:
+    ///       - to: the `SocketAddress` to which we should connect the `Channel`.
+    /// - returns: the future which will be notified once the operation completes.
+    public func connect(to address: SocketAddress, file: StaticString = #file, line: UInt = #line) -> EventLoopFuture<Void> {
+        let promise = makePromise(file: file, line: line)
         connect(to: address, promise: promise)
         return promise.futureResult
     }
 
-    public func write(_ data: NIOAny) -> EventLoopFuture<Void> {
-        let promise = makePromise()
+    /// Write data to the remote peer.
+    ///
+    /// Be aware that to be sure that data is really written to the remote peer you need to call `flush` or use `writeAndFlush`.
+    /// Calling `write` multiple times and then `flush` may allow the `Channel` to `write` multiple data objects to the remote peer with one syscall.
+    ///
+    /// - parameters:
+    ///       - data: the data to write
+    /// - returns: the future which will be notified once the operation completes.
+    public func write(_ data: NIOAny, file: StaticString = #file, line: UInt = #line) -> EventLoopFuture<Void> {
+        let promise = makePromise(file: file, line: line)
         write(data, promise: promise)
         return promise.futureResult
     }
 
-    public func writeAndFlush(_ data: NIOAny) -> EventLoopFuture<Void> {
-        let promise = makePromise()
+    /// Shortcut for calling `write` and `flush`.
+    ///
+    /// - parameters:
+    ///       - data: the data to write
+    /// - returns: the future which will be notified once the `write` operation completes.
+    public func writeAndFlush(_ data: NIOAny, file: StaticString = #file, line: UInt = #line) -> EventLoopFuture<Void> {
+        let promise = makePromise(file: file, line: line)
         writeAndFlush(data, promise: promise)
         return promise.futureResult
     }
 
-    public func close(mode: CloseMode = .all) -> EventLoopFuture<Void> {
-        let promise = makePromise()
+    /// Close the `Channel` and so the connection if one exists.
+    ///
+    /// - parameters:
+    ///       - mode: the `CloseMode` that is used
+    /// - returns: the future which will be notified once the operation completes.
+    public func close(mode: CloseMode = .all, file: StaticString = #file, line: UInt = #line) -> EventLoopFuture<Void> {
+        let promise = makePromise(file: file, line: line)
         close(mode: mode, promise: promise)
         return promise.futureResult
     }
 
-    public func triggerUserOutboundEvent(_ event: Any) -> EventLoopFuture<Void> {
-        let promise = makePromise()
+    /// Trigger a custom user outbound event which will flow through the `ChannelPipeline`.
+    ///
+    /// - parameters:
+    ///       - event: the event itself.
+    /// - returns: the future which will be notified once the operation completes.
+    public func triggerUserOutboundEvent(_ event: Any, file: StaticString = #file, line: UInt = #line) -> EventLoopFuture<Void> {
+        let promise = makePromise(file: file, line: line)
         triggerUserOutboundEvent(event, promise: promise)
         return promise.futureResult
     }

    ///
    /// - parameters:
    ///       - data: the data to write
    /// - returns: the future which will be notified once the `write` operation completes.
    func writeAndFlush(_ data: NIOAny) -> EventLoopFuture<Void>

    /// Shortcut for calling `write` and `flush`.
    ///
    /// - parameters:
    ///       - data: the data to write
    ///       - promise: the `EventLoopPromise` that will be notified once the `write` operation completes,
    ///                  or `nil` if not interested in the outcome of the operation.
    func writeAndFlush(_ data: NIOAny, promise: EventLoopPromise<Void>?)


    /// Register on an `EventLoop` and so have all its IO handled.
    ///
    /// - parameters:
    ///       - promise: the `EventLoopPromise` that will be notified once the operation completes,
    ///                  or `nil` if not interested in the outcome of the operation.
