starpc 0.50.0 → 0.52.0

package/srpc/channel.ts

@@ -26,6 +26,10 @@ export type ChannelPort =
   | MessagePort
   | { tx: BroadcastChannel; rx: BroadcastChannel }
 
+function isMessagePort(channel: ChannelPort): channel is MessagePort {
+  return 'postMessage' in channel && 'start' in channel
+}
+
 // ChannelStreamOpts are options for ChannelStream.
 export interface ChannelStreamOpts {
   // remoteOpen indicates that the remote already knows the channel is open.
@@ -149,7 +153,7 @@ export class ChannelStream<T = Uint8Array> implements Duplex<
 
     // wire up the message handlers
     const onMessage = this.onMessage.bind(this)
-    if (channel instanceof MessagePort) {
+    if (isMessagePort(channel)) {
       // MessagePort
       channel.onmessage = onMessage
       channel.start()
@@ -180,7 +184,7 @@ export class ChannelStream<T = Uint8Array> implements Duplex<
       return
     }
     msg.from = this.localId
-    if (this.channel instanceof MessagePort) {
+    if (isMessagePort(this.channel)) {
       this.channel.postMessage(msg)
     } else {
       this.channel.tx.postMessage(msg)
@@ -222,7 +226,7 @@ export class ChannelStream<T = Uint8Array> implements Duplex<
     this.localWriteClosed = true
     this.remoteWriteClosed = true
     // close channels
-    if (this.channel instanceof MessagePort) {
+    if (isMessagePort(this.channel)) {
       this.channel.onmessage = null
       this.channel.close()
     } else {

package/srpc/client-prefix.go

@@ -55,4 +55,4 @@ func (i *PrefixClient) stripCheckServiceIDPrefix(service string) (string, error)
 }
 
 // _ is a type assertion
-var _ Client = ((*PrefixClient)(nil))
+var _ Client = (*PrefixClient)(nil)

package/srpc/client-set.go

@@ -75,4 +75,4 @@ func (c *ClientSet) execCall(ctx context.Context, doCall func(client Client) err
 }
 
 // _ is a type assertion
-var _ Client = ((*ClientSet)(nil))
+var _ Client = (*ClientSet)(nil)

package/srpc/client.go

@@ -97,4 +97,4 @@ func (c *client) NewStream(ctx context.Context, service, method string, firstMsg
 }
 
 // _ is a type assertion
-var _ Client = ((*client)(nil))
+var _ Client = (*client)(nil)

package/srpc/client.ts

@@ -8,10 +8,9 @@ import { ClientRPC } from './client-rpc.js'
 import { writeToPushable } from './pushable.js'
 import { decodePacketSource, encodePacketSource } from './packet.js'
 import { OpenStreamCtr } from './open-stream-ctr.js'
-import { CallReceipt } from './call-receipt.js'
-import type { HeldCall, ReceiptRpc } from './call-receipt.js'
+
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
-export class Client implements ProtoRpc, ReceiptRpc {
+export class Client implements ProtoRpc {
   // openStreamCtr contains the OpenStreamFunc.
   private openStreamCtr: OpenStreamCtr
 
@@ -41,32 +40,6 @@ export class Client implements ProtoRpc, ReceiptRpc {
     throw err
   }
 
-  // requestWithReceipt reads one response and retains the call terminal.
-  public async requestWithReceipt(
-    service: string,
-    method: string,
-    data: Uint8Array,
-    abortSignal?: AbortSignal,
-  ): Promise<HeldCall> {
-    const call = await this.startRpc(service, method, data, abortSignal)
-    const iterator = call.rpcDataSource[Symbol.asyncIterator]()
-    try {
-      const result = await iterator.next()
-      if (result.done) {
-        throw new Error('empty response')
-      }
-      return {
-        response: result.value,
-        receipt: new CallReceipt(call, iterator),
-      }
-    } catch (err) {
-      await call.close(
-        err instanceof Error ? err : new Error('receipt read failed'),
-      )
-      throw err
-    }
-  }
-
   // clientStreamingRequest starts a client side streaming request.
   public async clientStreamingRequest(
     service: string,
@@ -144,8 +117,8 @@ export class Client implements ProtoRpc, ReceiptRpc {
     const stream = await openStreamFn()
     const call = new ClientRPC(rpcService, rpcMethod)
     const onAbort = () => {
-      call.writeCallCancel()
-      call.close(new Error(ERR_RPC_ABORT))
+      void call.writeCallCancel().catch(() => undefined)
+      void call.close(new Error(ERR_RPC_ABORT)).catch(() => undefined)
     }
     abortSignal?.addEventListener('abort', onAbort, { once: true })
     pipe(stream, decodePacketSource, call, encodePacketSource, stream)

package/srpc/common-rpc.go

@@ -31,8 +31,8 @@ type commonRPC struct {
 	writer PacketWriter
 	// writerClosed is set after writer has been closed locally.
 	writerClosed bool
-	// localCompleting is set while the local handler is publishing its terminal
-	// packet and closing the writer.
+	// localCompleting is set while the local handler is publishing its
+	// completion packet and closing the writer.
 	localCompleting bool
 	// localActive is set while the local handler goroutine may still be inside
 	// user code. Resource owners use Wait as a lifetime barrier, so cancellation
@@ -48,14 +48,8 @@ type commonRPC struct {
 	dataClosed bool
 	// remoteErr is an error set by the remote.
 	remoteErr error
-	// remoteCanceled distinguishes a received CallCancel from transport loss.
-	remoteCanceled bool
 	// remoteCompleted is set only by an explicit remote CallData completion.
 	remoteCompleted bool
-	// remoteTerminal is the first valid remote terminal.
-	remoteTerminal TerminalKind
-	// remoteTerminalSet records whether remoteTerminal is valid.
-	remoteTerminalSet bool
 }
 
 // initCommonRPC initializes the commonRPC.
@@ -124,41 +118,6 @@ func (c *commonRPC) Wait(ctx context.Context) error {
 	}
 }
 
-// WaitTerminal waits for and classifies the remote terminal of a held unary
-// invocation.
-func (c *commonRPC) WaitTerminal(ownerCtx context.Context) (TerminalKind, error) {
-	var ownerDone bool
-	for {
-		locked := c.bcast.Lock()
-		if c.remoteTerminalSet {
-			terminal := c.remoteTerminal
-			locked.Unlock()
-			return terminal, nil
-		}
-		if ownerDone {
-			err := ownerCtx.Err()
-			locked.Unlock()
-			return TerminalKind_TERMINAL_KIND_ABANDONED, err
-		}
-		waitCh := locked.WaitCh()
-		locked.Unlock()
-
-		select {
-		case <-ownerCtx.Done():
-			ownerDone = true
-		case <-waitCh:
-		}
-	}
-}
-
-// receiptTerminalKind returns the first valid remote terminal.
-func (c *commonRPC) receiptTerminalKind() (TerminalKind, bool) {
-	locked := c.bcast.Lock()
-	terminal, ok := c.remoteTerminal, c.remoteTerminalSet
-	locked.Unlock()
-	return terminal, ok
-}
-
 // ReadOne reads a single message and returns.
 //
 // returns io.EOF if the stream ended without a packet.
@@ -236,9 +195,6 @@ func (c *commonRPC) HandleStreamClose(closeErr error) {
 // HandleCallCancel handles the call cancel packet.
 func (c *commonRPC) HandleCallCancel() error {
 	locked := c.bcast.Lock()
-	if (!c.dataClosed || !c.writerClosed) && !c.remoteTerminalSet {
-		c.remoteCanceled = true
-	}
 	writer := c.handleStreamCloseLocked(&locked, context.Canceled)
 	locked.Unlock()
 	if writer != nil {
@@ -277,11 +233,7 @@ func (c *commonRPC) HandleCallData(pkt *CallData) error {
 	if complete {
 		c.dataClosed = true
 		if len(pktErr) == 0 {
-			if c.recordRemoteTerminalLocked(TerminalKind_TERMINAL_KIND_COMMITTED) {
-				c.remoteCompleted = true
-			}
-		} else {
-			c.recordRemoteTerminalLocked(TerminalKind_TERMINAL_KIND_TRANSPORT_LOST)
+			c.remoteCompleted = true
 		}
 	}
 
@@ -291,15 +243,6 @@ func (c *commonRPC) HandleCallData(pkt *CallData) error {
 	return err
 }
 
-func (c *commonRPC) recordRemoteTerminalLocked(kind TerminalKind) bool {
-	if c.remoteTerminalSet {
-		return false
-	}
-	c.remoteTerminal = kind
-	c.remoteTerminalSet = true
-	return true
-}
-
 func (c *commonRPC) handleStreamCloseLocked(
 	locked *broadcast.Locked,
 	closeErr error,
@@ -307,19 +250,22 @@ func (c *commonRPC) handleStreamCloseLocked(
 	if c.dataClosed && c.writerClosed {
 		return nil
 	}
+	// A peer that closes its side reports the end of the stream. Transports
+	// disagree on whether they surface that as io.EOF or as no error at all,
+	// and it means the same thing either way, so settle it here rather than in
+	// each transport. It says nothing about whether a completion preceded it.
+	if errors.Is(closeErr, io.EOF) {
+		closeErr = nil
+	}
 	normalRemoteCloseAfterLocalComplete := closeErr == nil && (c.localCompleting || c.localDone)
 	if closeErr != nil && c.remoteErr == nil {
 		c.remoteErr = closeErr
 	}
-	if !normalRemoteCloseAfterLocalComplete && !c.remoteTerminalSet {
-		terminal := TerminalKind_TERMINAL_KIND_CLOSED
-		if closeErr != nil {
-			terminal = TerminalKind_TERMINAL_KIND_TRANSPORT_LOST
-			if c.remoteCanceled {
-				terminal = TerminalKind_TERMINAL_KIND_CANCELED
-			}
-		}
-		c.recordRemoteTerminalLocked(terminal)
+	// A clean close that arrives with no completion behind it leaves the call
+	// without a verdict. Reading io.EOF there says the stream ended in good
+	// order, which is the one thing we do not know.
+	if closeErr == nil && !normalRemoteCloseAfterLocalComplete && !c.remoteCompleted && c.remoteErr == nil {
+		c.remoteErr = ErrClosedBeforeCompletion
 	}
 	c.dataClosed = true
 	if !normalRemoteCloseAfterLocalComplete {

package/srpc/common-rpc.ts

@@ -3,12 +3,7 @@ import type { Sink, Source } from 'it-stream-types'
 import { pushable, type Pushable } from 'it-pushable'
 import { CompleteMessage } from '@aptre/protobuf-es-lite'
 
-import {
-  Packet,
-  TerminalKind,
-  type CallData,
-  type CallStart,
-} from './rpcproto.pb.js'
+import { Packet, type CallData, type CallStart } from './rpcproto.pb.js'
 import { ERR_RPC_ABORT, RemoteRPCError } from './errors.js'
 
 const maxBufferedOutgoingPackets = 1
@@ -39,27 +34,15 @@ export class CommonRPC {
 
   // closed indicates this rpc has been closed already.
   private closed?: true | Error
-  // remoteCompleted is set only by an explicit remote CallData completion.
-  private remoteCompleted = false
   // remoteError records a remote error or transport failure.
   private remoteError?: Error
-  // remoteSourceClosed records an incoming source ending without a packet error.
-  private remoteSourceClosed = false
-  // remoteTerminal is the first valid remote terminal.
-  private remoteTerminal?: TerminalKind
-  // invocationController cancels the server invocation on a remote terminal.
+  // invocationController cancels the server invocation when the RPC closes.
   private readonly invocationController = new AbortController()
-  // terminalPromise resolves when a remote terminal is recorded.
-  private readonly terminalPromise: Promise<void>
-  private resolveTerminal!: () => void
 
   // writeDrainAbort wakes writers waiting for outbound stream drain on close.
   private readonly writeDrainAbort = new AbortController()
 
   constructor() {
-    const { promise, resolve } = Promise.withResolvers<void>()
-    this.terminalPromise = promise
-    this.resolveTerminal = resolve
     this.sink = this._createSink()
     this.source = this._source
     this.rpcDataSource = this._rpcDataSource
@@ -70,57 +53,11 @@ export class CommonRPC {
     return this.closed ?? false
   }
 
-  // invocationSignal is canceled when the RPC reaches a terminal.
+  // invocationSignal is canceled when the RPC closes.
   protected get invocationSignal(): AbortSignal {
     return this.invocationController.signal
   }
 
-  // waitTerminal waits for the remote terminal or external owner cancellation.
-  protected async waitTerminal(
-    ownerSignal: AbortSignal,
-  ): Promise<TerminalKind> {
-    const { promise: ownerDone, resolve: resolveOwnerDone } =
-      Promise.withResolvers<void>()
-    const onAbort = () => resolveOwnerDone()
-    ownerSignal.addEventListener('abort', onAbort, { once: true })
-    let ownerAborted = ownerSignal.aborted
-    try {
-      for (;;) {
-        const terminal = this.getTerminalKind()
-        if (terminal !== undefined) {
-          if (
-            terminal === TerminalKind.CLOSED &&
-            this.remoteSourceClosed &&
-            !this.closed
-          ) {
-            await this.close()
-          }
-          return terminal
-        }
-        if (ownerAborted) {
-          return TerminalKind.ABANDONED
-        }
-        await Promise.race([this.terminalPromise, ownerDone])
-        ownerAborted = ownerSignal.aborted
-      }
-    } finally {
-      ownerSignal.removeEventListener('abort', onAbort)
-    }
-  }
-
-  // getTerminalKind returns the observed remote terminal, if any.
-  public getTerminalKind(): TerminalKind | undefined {
-    return this.remoteTerminal
-  }
-
-  private recordRemoteTerminal(kind: TerminalKind) {
-    if (this.remoteTerminal !== undefined) {
-      return
-    }
-    this.remoteTerminal = kind
-    this.resolveTerminal()
-  }
-
   // writeCallData writes the call data packet.
   public async writeCallData(
     data?: Uint8Array,
@@ -276,20 +213,15 @@ export class CommonRPC {
     if (remoteError) {
       this.remoteError ??= remoteError
       this.invocationController.abort()
-      this.recordRemoteTerminal(TerminalKind.TRANSPORT_LOST)
     }
     if (packet.complete && !remoteError) {
-      this.remoteCompleted = true
-      this.recordRemoteTerminal(TerminalKind.COMMITTED)
       this._rpcDataSource.end(remoteError)
     } else if (remoteError) {
       this._rpcDataSource.end(remoteError)
     }
   }
-
-  // handleCallCancel handles a CallCancel packet.
+  // handleCallCancel aborts the invocation and closes the call.
   public async handleCallCancel() {
-    this.recordRemoteTerminal(TerminalKind.CANCELED)
     await this.close(new Error(ERR_RPC_ABORT))
   }
 
@@ -302,9 +234,6 @@ export class CommonRPC {
     if (!this.remoteError && err) {
       this.remoteError = err
     }
-    this.recordRemoteTerminal(
-      err ? TerminalKind.TRANSPORT_LOST : TerminalKind.CLOSED,
-    )
     this.invocationController.abort()
     // note: this does nothing if _source is already ended.
     if (err && err.message) {
@@ -330,8 +259,6 @@ export class CommonRPC {
             await this.handlePacket(msg)
           }
         }
-        this.remoteSourceClosed = true
-        this.recordRemoteTerminal(TerminalKind.CLOSED)
       } catch (err) {
         this.close(err as Error)
       }

package/srpc/common-rpc_test.go

@@ -3,6 +3,7 @@ package srpc
 import (
 	"bytes"
 	"context"
+	"errors"
 	"io"
 	"sync"
 	"sync/atomic"
@@ -423,3 +424,83 @@ func TestCommonRPCReadOneQueuedDoesNotAllocate(t *testing.T) {
 		t.Fatalf("expected queued ReadOne to avoid allocations, got %f", allocs)
 	}
 }
+
+func TestRemoteCloseWithoutCompletionNamesTheMissingCompletion(t *testing.T) {
+	writer := &closeCountingPacketWriter{}
+	rpc := NewClientRPC(context.Background(), "service", "method")
+	if err := rpc.Start(writer, false, nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	// the transport ends the stream in good order with nothing behind it,
+	// which is what a dropped completion packet looks like from here.
+	rpc.HandleStreamClose(nil)
+
+	_, err := rpc.ReadOne()
+	if !errors.Is(err, ErrClosedBeforeCompletion) {
+		t.Fatalf("read after a truncated stream reported %v, want the missing completion", err)
+	}
+	if errors.Is(err, io.EOF) {
+		t.Fatalf("read after a truncated stream claims the call ended in good order: %v", err)
+	}
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("read after a truncated stream stopped satisfying a cancellation check: %v", err)
+	}
+	if got := err.Error(); got == context.Canceled.Error() {
+		t.Fatalf("read after a truncated stream still claims a cancellation happened: %q", got)
+	}
+	if err := rpc.Wait(context.Background()); !errors.Is(err, ErrClosedBeforeCompletion) {
+		t.Fatalf("wait after a truncated stream reported %v, want the missing completion", err)
+	}
+}
+
+func TestRemoteCloseReportingEOFNamesTheMissingCompletion(t *testing.T) {
+	writer := &closeCountingPacketWriter{}
+	rpc := NewClientRPC(context.Background(), "service", "method")
+	if err := rpc.Start(writer, false, nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	// rpcstream surfaces the peer's close as io.EOF rather than as no error.
+	rpc.HandleStreamClose(io.EOF)
+
+	_, err := rpc.ReadOne()
+	if !errors.Is(err, ErrClosedBeforeCompletion) {
+		t.Fatalf("read after an EOF close reported %v, want the missing completion", err)
+	}
+}
+
+func TestRemoteCloseAfterCompletionStillEndsTheStream(t *testing.T) {
+	writer := &closeCountingPacketWriter{}
+	rpc := NewClientRPC(context.Background(), "service", "method")
+	if err := rpc.Start(writer, false, nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	if err := rpc.HandleCallData(&CallData{Complete: true}); err != nil {
+		t.Fatalf("handle completion: %v", err)
+	}
+	rpc.HandleStreamClose(nil)
+
+	if _, err := rpc.ReadOne(); !errors.Is(err, io.EOF) {
+		t.Fatalf("read after a completed call reported %v, want the end of the stream", err)
+	}
+}
+
+func TestClientRPCCloseReportsALocalCancellation(t *testing.T) {
+	writer := &closeCountingPacketWriter{}
+	rpc := NewClientRPC(context.Background(), "service", "method")
+	if err := rpc.Start(writer, false, nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	rpc.Close()
+
+	_, err := rpc.ReadOne()
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("read after a local close reported %v, want a cancellation", err)
+	}
+	if errors.Is(err, ErrClosedBeforeCompletion) {
+		t.Fatalf("a close this side performed was blamed on the remote: %v", err)
+	}
+}

package/srpc/errors.go

@@ -1,6 +1,9 @@
 package srpc
 
-import "errors"
+import (
+	"context"
+	"errors"
+)
 
 var (
 	// ErrReset is returned when a stream is reset.
@@ -24,3 +27,25 @@ var (
 	// ErrNilWriter is returned if the rpc writer is nil.
 	ErrNilWriter = errors.New("writer cannot be nil")
 )
+
+// ErrClosedBeforeCompletion is the error a call reports when its stream closed
+// without the remote sending a completion or an error. The call has no verdict:
+// the handler may have finished with its answer lost in the transport, or it may
+// never have run. Anything read from the call after that point fails with this.
+//
+// It unwraps to context.Canceled, which is what this case reported before the
+// distinction existed, so a caller that tests for cancellation keeps working.
+var ErrClosedBeforeCompletion error = closedBeforeCompletion{}
+
+// closedBeforeCompletion carries ErrClosedBeforeCompletion.
+type closedBeforeCompletion struct{}
+
+// Error returns the error message.
+func (closedBeforeCompletion) Error() string {
+	return "stream closed before the remote reported completion"
+}
+
+// Unwrap returns the cancellation this case reported historically.
+func (closedBeforeCompletion) Unwrap() error {
+	return context.Canceled
+}

package/srpc/handler.ts

@@ -1,13 +1,58 @@
 import type { Sink, Source } from 'it-stream-types'
-import { ServiceDefinition, ServiceMethodDefinitions } from './definition.js'
+import { MethodKind, type MessageType } from '@aptre/protobuf-es-lite'
+import type { MessageStream } from './message.js'
+import {
+  type MethodDefinition,
+  ServiceDefinition,
+  ServiceMethodDefinitions,
+} from './definition.js'
 import { createInvokeFn } from './invoker.js'
-import type { ServerInvocation } from './server-invocation.js'
+import type { ServerContext } from './server-context.js'
+
+type MessageOf<T> = T extends MessageType<infer M> ? M : never
+
+type ServerMethod<T> =
+  T extends MethodDefinition<
+    infer Request,
+    infer Response,
+    infer Kind,
+    infer _Idempotency
+  >
+    ? Kind extends MethodKind.Unary
+      ? (
+          request: MessageOf<Request>,
+          abortSignal: AbortSignal,
+          context: ServerContext,
+        ) => Promise<MessageOf<Response>>
+      : Kind extends MethodKind.ServerStreaming
+        ? (
+            request: MessageOf<Request>,
+            abortSignal: AbortSignal,
+            context: ServerContext,
+          ) => MessageStream<MessageOf<Response>>
+        : Kind extends MethodKind.ClientStreaming
+          ? (
+              request: MessageStream<MessageOf<Request>>,
+              abortSignal: AbortSignal,
+              context: ServerContext,
+            ) => Promise<MessageOf<Response>>
+          : (
+              request: MessageStream<MessageOf<Request>>,
+              abortSignal: AbortSignal,
+              context: ServerContext,
+            ) => MessageStream<MessageOf<Response>>
+    : never
+
+export type HandlerImplementation<T extends ServiceMethodDefinitions> =
+  Partial<{
+    [Method in keyof T]: ServerMethod<T[Method]>
+  }>
 
 // InvokeFn describes an SRPC call method invoke function.
 export type InvokeFn = (
   dataSource: Source<Uint8Array>,
   dataSink: Sink<Source<Uint8Array>>,
-  invocation?: ServerInvocation,
+  context: ServerContext,
 ) => Promise<void>
 
 // Handler describes a SRPC call handler implementation.
@@ -63,7 +108,11 @@ export class StaticHandler implements Handler {
 // if serviceID is not set, uses the fullName of the service as the identifier.
 export function createHandler<
   T extends ServiceMethodDefinitions = ServiceMethodDefinitions,
->(definition: ServiceDefinition<T>, impl: any, serviceID?: string): Handler {
+>(
+  definition: ServiceDefinition<T>,
+  impl: HandlerImplementation<T>,
+  serviceID?: string,
+): Handler {
   // serviceID defaults to the full name of the service from Protobuf.
   serviceID = serviceID || definition.typeName
 
@@ -71,7 +120,7 @@ export function createHandler<
   const methodMap: MethodMap = {}
   for (const methodInfo of Object.values(definition.methods)) {
     const methodName = methodInfo.name
-    let methodProto = impl[methodName]
+    let methodProto = impl[methodName as keyof T] as any
     if (!methodProto) {
       continue
     }

package/srpc/index.ts

@@ -6,10 +6,6 @@ export {
   castToError,
 } from './errors.js'
 export { Client } from './client.js'
-export { CallReceipt } from './call-receipt.js'
-export type { HeldCall, ReceiptRpc } from './call-receipt.js'
-export { ServerInvocation } from './server-invocation.js'
-export { TerminalKind } from './rpcproto.pb.js'
 export { Server } from './server.js'
 export { StreamConn } from './conn.js'
 export type { StreamConnParams, StreamHandler } from './conn.js'
@@ -87,3 +83,10 @@ export {
 } from './pushable.js'
 export { Watchdog } from './watchdog.js'
 export type { ProtoRpc } from './proto-rpc.js'
+
+export {
+  createContextKey,
+  serverContextValue,
+  withServerContextValue,
+} from './server-context.js'
+export type { ContextKey, ServerContext } from './server-context.js'

package/srpc/invoker-prefix.go

@@ -37,4 +37,4 @@ func (i *PrefixInvoker) InvokeMethod(serviceID, methodID string, strm Stream) (b
 }
 
 // _ is a type assertion
-var _ Invoker = ((*PrefixInvoker)(nil))
+var _ Invoker = (*PrefixInvoker)(nil)

package/srpc/invoker.go

@@ -37,7 +37,7 @@ func (s InvokerSlice) InvokeMethod(serviceID, methodID string, strm Stream) (boo
 }
 
 // _ is a type assertion
-var _ Invoker = (InvokerSlice)(nil)
+var _ Invoker = InvokerSlice(nil)
 
 // InvokerFunc is a function implementing InvokeMethod.
 type InvokerFunc func(serviceID, methodID string, strm Stream) (bool, error)
@@ -52,4 +52,4 @@ func (f InvokerFunc) InvokeMethod(serviceID, methodID string, strm Stream) (bool
 	return f(serviceID, methodID, strm)
 }
 
-var _ Invoker = (InvokerFunc)(nil)
+var _ Invoker = InvokerFunc(nil)