Stop exposing streaming object class

1 files changed, 780 insertions, 325 deletions

diff --git a/test/cpp/codegen/compiler_test_golden b/test/cpp/codegen/compiler_test_golden
index 7a25f51d10..1a5fe27932 100644
--- a/test/cpp/codegen/compiler_test_golden
+++ b/test/cpp/codegen/compiler_test_golden
@@ -26,7 +26,6 @@
 
 #include "src/proto/grpc/testing/compiler_test.pb.h"
 
-#include <functional>
 #include <grpcpp/impl/codegen/async_generic_service.h>
 #include <grpcpp/impl/codegen/async_stream.h>
 #include <grpcpp/impl/codegen/async_unary_call.h>
@@ -39,6 +38,7 @@
 #include <grpcpp/impl/codegen/status.h>
 #include <grpcpp/impl/codegen/stub_options.h>
 #include <grpcpp/impl/codegen/sync_stream.h>
+#include <functional>
 
 namespace grpc {
 class CompletionQueue;
@@ -64,294 +64,556 @@ class ServiceA final {
    public:
     virtual ~StubInterface() {}
     // MethodA1 leading comment 1
-    virtual ::grpc::Status MethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::testing::Response* response) = 0;
-    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>> AsyncMethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>>(AsyncMethodA1Raw(context, request, cq));
-    }
-    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>> PrepareAsyncMethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>>(PrepareAsyncMethodA1Raw(context, request, cq));
+    virtual ::grpc::Status MethodA1(::grpc::ClientContext* context,
+                                    const ::grpc::testing::Request& request,
+                                    ::grpc::testing::Response* response) = 0;
+    std::unique_ptr<
+        ::grpc::ClientAsyncResponseReaderInterface<::grpc::testing::Response>>
+    AsyncMethodA1(::grpc::ClientContext* context,
+                  const ::grpc::testing::Request& request,
+                  ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<
+          ::grpc::testing::Response>>(AsyncMethodA1Raw(context, request, cq));
+    }
+    std::unique_ptr<
+        ::grpc::ClientAsyncResponseReaderInterface<::grpc::testing::Response>>
+    PrepareAsyncMethodA1(::grpc::ClientContext* context,
+                         const ::grpc::testing::Request& request,
+                         ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<
+          ::grpc::testing::Response>>(
+          PrepareAsyncMethodA1Raw(context, request, cq));
     }
     // MethodA1 trailing comment 1
     // MethodA2 detached leading comment 1
     //
     // Method A2 leading comment 1
     // Method A2 leading comment 2
-    std::unique_ptr< ::grpc::ClientWriterInterface< ::grpc::testing::Request>> MethodA2(::grpc::ClientContext* context, ::grpc::testing::Response* response) {
-      return std::unique_ptr< ::grpc::ClientWriterInterface< ::grpc::testing::Request>>(MethodA2Raw(context, response));
-    }
-    std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::grpc::testing::Request>> AsyncMethodA2(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq, void* tag) {
-      return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::grpc::testing::Request>>(AsyncMethodA2Raw(context, response, cq, tag));
-    }
-    std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::grpc::testing::Request>> PrepareAsyncMethodA2(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::grpc::testing::Request>>(PrepareAsyncMethodA2Raw(context, response, cq));
+    std::unique_ptr<::grpc::ClientWriterInterface<::grpc::testing::Request>>
+    MethodA2(::grpc::ClientContext* context,
+             ::grpc::testing::Response* response) {
+      return std::unique_ptr<
+          ::grpc::ClientWriterInterface<::grpc::testing::Request>>(
+          MethodA2Raw(context, response));
+    }
+    std::unique_ptr<
+        ::grpc::ClientAsyncWriterInterface<::grpc::testing::Request>>
+    AsyncMethodA2(::grpc::ClientContext* context,
+                  ::grpc::testing::Response* response,
+                  ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr<
+          ::grpc::ClientAsyncWriterInterface<::grpc::testing::Request>>(
+          AsyncMethodA2Raw(context, response, cq, tag));
+    }
+    std::unique_ptr<
+        ::grpc::ClientAsyncWriterInterface<::grpc::testing::Request>>
+    PrepareAsyncMethodA2(::grpc::ClientContext* context,
+                         ::grpc::testing::Response* response,
+                         ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr<
+          ::grpc::ClientAsyncWriterInterface<::grpc::testing::Request>>(
+          PrepareAsyncMethodA2Raw(context, response, cq));
     }
     // MethodA2 trailing comment 1
     // Method A3 leading comment 1
-    std::unique_ptr< ::grpc::ClientReaderInterface< ::grpc::testing::Response>> MethodA3(::grpc::ClientContext* context, const ::grpc::testing::Request& request) {
-      return std::unique_ptr< ::grpc::ClientReaderInterface< ::grpc::testing::Response>>(MethodA3Raw(context, request));
-    }
-    std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::grpc::testing::Response>> AsyncMethodA3(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq, void* tag) {
-      return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::grpc::testing::Response>>(AsyncMethodA3Raw(context, request, cq, tag));
-    }
-    std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::grpc::testing::Response>> PrepareAsyncMethodA3(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::grpc::testing::Response>>(PrepareAsyncMethodA3Raw(context, request, cq));
+    std::unique_ptr<::grpc::ClientReaderInterface<::grpc::testing::Response>>
+    MethodA3(::grpc::ClientContext* context,
+             const ::grpc::testing::Request& request) {
+      return std::unique_ptr<
+          ::grpc::ClientReaderInterface<::grpc::testing::Response>>(
+          MethodA3Raw(context, request));
+    }
+    std::unique_ptr<
+        ::grpc::ClientAsyncReaderInterface<::grpc::testing::Response>>
+    AsyncMethodA3(::grpc::ClientContext* context,
+                  const ::grpc::testing::Request& request,
+                  ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr<
+          ::grpc::ClientAsyncReaderInterface<::grpc::testing::Response>>(
+          AsyncMethodA3Raw(context, request, cq, tag));
+    }
+    std::unique_ptr<
+        ::grpc::ClientAsyncReaderInterface<::grpc::testing::Response>>
+    PrepareAsyncMethodA3(::grpc::ClientContext* context,
+                         const ::grpc::testing::Request& request,
+                         ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr<
+          ::grpc::ClientAsyncReaderInterface<::grpc::testing::Response>>(
+          PrepareAsyncMethodA3Raw(context, request, cq));
     }
     // Method A3 trailing comment 1
     // Method A4 leading comment 1
-    std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::grpc::testing::Request, ::grpc::testing::Response>> MethodA4(::grpc::ClientContext* context) {
-      return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::grpc::testing::Request, ::grpc::testing::Response>>(MethodA4Raw(context));
-    }
-    std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::grpc::testing::Request, ::grpc::testing::Response>> AsyncMethodA4(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
-      return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::grpc::testing::Request, ::grpc::testing::Response>>(AsyncMethodA4Raw(context, cq, tag));
-    }
-    std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::grpc::testing::Request, ::grpc::testing::Response>> PrepareAsyncMethodA4(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::grpc::testing::Request, ::grpc::testing::Response>>(PrepareAsyncMethodA4Raw(context, cq));
+    std::unique_ptr<::grpc::ClientReaderWriterInterface<
+        ::grpc::testing::Request, ::grpc::testing::Response>>
+    MethodA4(::grpc::ClientContext* context) {
+      return std::unique_ptr<::grpc::ClientReaderWriterInterface<
+          ::grpc::testing::Request, ::grpc::testing::Response>>(
+          MethodA4Raw(context));
+    }
+    std::unique_ptr<::grpc::ClientAsyncReaderWriterInterface<
+        ::grpc::testing::Request, ::grpc::testing::Response>>
+    AsyncMethodA4(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq,
+                  void* tag) {
+      return std::unique_ptr<::grpc::ClientAsyncReaderWriterInterface<
+          ::grpc::testing::Request, ::grpc::testing::Response>>(
+          AsyncMethodA4Raw(context, cq, tag));
+    }
+    std::unique_ptr<::grpc::ClientAsyncReaderWriterInterface<
+        ::grpc::testing::Request, ::grpc::testing::Response>>
+    PrepareAsyncMethodA4(::grpc::ClientContext* context,
+                         ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr<::grpc::ClientAsyncReaderWriterInterface<
+          ::grpc::testing::Request, ::grpc::testing::Response>>(
+          PrepareAsyncMethodA4Raw(context, cq));
     }
     // Method A4 trailing comment 1
     class experimental_async_interface {
      public:
       virtual ~experimental_async_interface() {}
       // MethodA1 leading comment 1
-      virtual void MethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void MethodA1(::grpc::ClientContext* context,
+                            const ::grpc::testing::Request* request,
+                            ::grpc::testing::Response* response,
+                            std::function<void(::grpc::Status)>) = 0;
       // MethodA1 trailing comment 1
       // MethodA2 detached leading comment 1
       //
       // Method A2 leading comment 1
       // Method A2 leading comment 2
-      virtual ::grpc::experimental::ClientCallbackWriter< ::grpc::testing::Request>* MethodA2(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::experimental::ClientWriteReactor* reactor) = 0;
+      virtual void MethodA2(
+          ::grpc::ClientContext* context, ::grpc::testing::Response* response,
+          ::grpc::experimental::ClientWriteReactor<::grpc::testing::Request>*
+              reactor) = 0;
       // MethodA2 trailing comment 1
       // Method A3 leading comment 1
-      virtual ::grpc::experimental::ClientCallbackReader< ::grpc::testing::Response>* MethodA3(::grpc::ClientContext* context, ::grpc::testing::Request* request, ::grpc::experimental::ClientReadReactor* reactor) = 0;
+      virtual void MethodA3(
+          ::grpc::ClientContext* context, ::grpc::testing::Request* request,
+          ::grpc::experimental::ClientReadReactor<::grpc::testing::Response>*
+              reactor) = 0;
       // Method A3 trailing comment 1
       // Method A4 leading comment 1
-      virtual ::grpc::experimental::ClientCallbackReaderWriter< ::grpc::testing::Request, ::grpc::testing::Response>* MethodA4(::grpc::ClientContext* context, ::grpc::experimental::ClientBidiReactor* reactor) = 0;
+      virtual void MethodA4(
+          ::grpc::ClientContext* context,
+          ::grpc::experimental::ClientBidiReactor<::grpc::testing::Request,
+                                                  ::grpc::testing::Response>*
+              reactor) = 0;
       // Method A4 trailing comment 1
     };
-    virtual class experimental_async_interface* experimental_async() { return nullptr; }
-  private:
-    virtual ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>* AsyncMethodA1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) = 0;
-    virtual ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>* PrepareAsyncMethodA1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) = 0;
-    virtual ::grpc::ClientWriterInterface< ::grpc::testing::Request>* MethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response) = 0;
-    virtual ::grpc::ClientAsyncWriterInterface< ::grpc::testing::Request>* AsyncMethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq, void* tag) = 0;
-    virtual ::grpc::ClientAsyncWriterInterface< ::grpc::testing::Request>* PrepareAsyncMethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq) = 0;
-    virtual ::grpc::ClientReaderInterface< ::grpc::testing::Response>* MethodA3Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request) = 0;
-    virtual ::grpc::ClientAsyncReaderInterface< ::grpc::testing::Response>* AsyncMethodA3Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq, void* tag) = 0;
-    virtual ::grpc::ClientAsyncReaderInterface< ::grpc::testing::Response>* PrepareAsyncMethodA3Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) = 0;
-    virtual ::grpc::ClientReaderWriterInterface< ::grpc::testing::Request, ::grpc::testing::Response>* MethodA4Raw(::grpc::ClientContext* context) = 0;
-    virtual ::grpc::ClientAsyncReaderWriterInterface< ::grpc::testing::Request, ::grpc::testing::Response>* AsyncMethodA4Raw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
-    virtual ::grpc::ClientAsyncReaderWriterInterface< ::grpc::testing::Request, ::grpc::testing::Response>* PrepareAsyncMethodA4Raw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
+    virtual class experimental_async_interface* experimental_async() {
+      return nullptr;
+    }
+
+   private:
+    virtual ::grpc::ClientAsyncResponseReaderInterface<
+        ::grpc::testing::Response>*
+    AsyncMethodA1Raw(::grpc::ClientContext* context,
+                     const ::grpc::testing::Request& request,
+                     ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface<
+        ::grpc::testing::Response>*
+    PrepareAsyncMethodA1Raw(::grpc::ClientContext* context,
+                            const ::grpc::testing::Request& request,
+                            ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientWriterInterface<::grpc::testing::Request>*
+    MethodA2Raw(::grpc::ClientContext* context,
+                ::grpc::testing::Response* response) = 0;
+    virtual ::grpc::ClientAsyncWriterInterface<::grpc::testing::Request>*
+    AsyncMethodA2Raw(::grpc::ClientContext* context,
+                     ::grpc::testing::Response* response,
+                     ::grpc::CompletionQueue* cq, void* tag) = 0;
+    virtual ::grpc::ClientAsyncWriterInterface<::grpc::testing::Request>*
+    PrepareAsyncMethodA2Raw(::grpc::ClientContext* context,
+                            ::grpc::testing::Response* response,
+                            ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientReaderInterface<::grpc::testing::Response>*
+    MethodA3Raw(::grpc::ClientContext* context,
+                const ::grpc::testing::Request& request) = 0;
+    virtual ::grpc::ClientAsyncReaderInterface<::grpc::testing::Response>*
+    AsyncMethodA3Raw(::grpc::ClientContext* context,
+                     const ::grpc::testing::Request& request,
+                     ::grpc::CompletionQueue* cq, void* tag) = 0;
+    virtual ::grpc::ClientAsyncReaderInterface<::grpc::testing::Response>*
+    PrepareAsyncMethodA3Raw(::grpc::ClientContext* context,
+                            const ::grpc::testing::Request& request,
+                            ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientReaderWriterInterface<::grpc::testing::Request,
+                                                ::grpc::testing::Response>*
+    MethodA4Raw(::grpc::ClientContext* context) = 0;
+    virtual ::grpc::ClientAsyncReaderWriterInterface<::grpc::testing::Request,
+                                                     ::grpc::testing::Response>*
+    AsyncMethodA4Raw(::grpc::ClientContext* context,
+                     ::grpc::CompletionQueue* cq, void* tag) = 0;
+    virtual ::grpc::ClientAsyncReaderWriterInterface<::grpc::testing::Request,
+                                                     ::grpc::testing::Response>*
+    PrepareAsyncMethodA4Raw(::grpc::ClientContext* context,
+                            ::grpc::CompletionQueue* cq) = 0;
   };
   class Stub final : public StubInterface {
    public:
-    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel);
-    ::grpc::Status MethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::testing::Response* response) override;
-    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>> AsyncMethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>>(AsyncMethodA1Raw(context, request, cq));
-    }
-    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>> PrepareAsyncMethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>>(PrepareAsyncMethodA1Raw(context, request, cq));
-    }
-    std::unique_ptr< ::grpc::ClientWriter< ::grpc::testing::Request>> MethodA2(::grpc::ClientContext* context, ::grpc::testing::Response* response) {
-      return std::unique_ptr< ::grpc::ClientWriter< ::grpc::testing::Request>>(MethodA2Raw(context, response));
-    }
-    std::unique_ptr< ::grpc::ClientAsyncWriter< ::grpc::testing::Request>> AsyncMethodA2(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq, void* tag) {
-      return std::unique_ptr< ::grpc::ClientAsyncWriter< ::grpc::testing::Request>>(AsyncMethodA2Raw(context, response, cq, tag));
-    }
-    std::unique_ptr< ::grpc::ClientAsyncWriter< ::grpc::testing::Request>> PrepareAsyncMethodA2(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncWriter< ::grpc::testing::Request>>(PrepareAsyncMethodA2Raw(context, response, cq));
-    }
-    std::unique_ptr< ::grpc::ClientReader< ::grpc::testing::Response>> MethodA3(::grpc::ClientContext* context, const ::grpc::testing::Request& request) {
-      return std::unique_ptr< ::grpc::ClientReader< ::grpc::testing::Response>>(MethodA3Raw(context, request));
-    }
-    std::unique_ptr< ::grpc::ClientAsyncReader< ::grpc::testing::Response>> AsyncMethodA3(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq, void* tag) {
-      return std::unique_ptr< ::grpc::ClientAsyncReader< ::grpc::testing::Response>>(AsyncMethodA3Raw(context, request, cq, tag));
-    }
-    std::unique_ptr< ::grpc::ClientAsyncReader< ::grpc::testing::Response>> PrepareAsyncMethodA3(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncReader< ::grpc::testing::Response>>(PrepareAsyncMethodA3Raw(context, request, cq));
-    }
-    std::unique_ptr< ::grpc::ClientReaderWriter< ::grpc::testing::Request, ::grpc::testing::Response>> MethodA4(::grpc::ClientContext* context) {
-      return std::unique_ptr< ::grpc::ClientReaderWriter< ::grpc::testing::Request, ::grpc::testing::Response>>(MethodA4Raw(context));
-    }
-    std::unique_ptr<  ::grpc::ClientAsyncReaderWriter< ::grpc::testing::Request, ::grpc::testing::Response>> AsyncMethodA4(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
-      return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::grpc::testing::Request, ::grpc::testing::Response>>(AsyncMethodA4Raw(context, cq, tag));
-    }
-    std::unique_ptr<  ::grpc::ClientAsyncReaderWriter< ::grpc::testing::Request, ::grpc::testing::Response>> PrepareAsyncMethodA4(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::grpc::testing::Request, ::grpc::testing::Response>>(PrepareAsyncMethodA4Raw(context, cq));
-    }
-    class experimental_async final :
-      public StubInterface::experimental_async_interface {
+    Stub(const std::shared_ptr<::grpc::ChannelInterface>& channel);
+    ::grpc::Status MethodA1(::grpc::ClientContext* context,
+                            const ::grpc::testing::Request& request,
+                            ::grpc::testing::Response* response) override;
+    std::unique_ptr<
+        ::grpc::ClientAsyncResponseReader<::grpc::testing::Response>>
+    AsyncMethodA1(::grpc::ClientContext* context,
+                  const ::grpc::testing::Request& request,
+                  ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr<
+          ::grpc::ClientAsyncResponseReader<::grpc::testing::Response>>(
+          AsyncMethodA1Raw(context, request, cq));
+    }
+    std::unique_ptr<
+        ::grpc::ClientAsyncResponseReader<::grpc::testing::Response>>
+    PrepareAsyncMethodA1(::grpc::ClientContext* context,
+                         const ::grpc::testing::Request& request,
+                         ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr<
+          ::grpc::ClientAsyncResponseReader<::grpc::testing::Response>>(
+          PrepareAsyncMethodA1Raw(context, request, cq));
+    }
+    std::unique_ptr<::grpc::ClientWriter<::grpc::testing::Request>> MethodA2(
+        ::grpc::ClientContext* context, ::grpc::testing::Response* response) {
+      return std::unique_ptr<::grpc::ClientWriter<::grpc::testing::Request>>(
+          MethodA2Raw(context, response));
+    }
+    std::unique_ptr<::grpc::ClientAsyncWriter<::grpc::testing::Request>>
+    AsyncMethodA2(::grpc::ClientContext* context,
+                  ::grpc::testing::Response* response,
+                  ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr<
+          ::grpc::ClientAsyncWriter<::grpc::testing::Request>>(
+          AsyncMethodA2Raw(context, response, cq, tag));
+    }
+    std::unique_ptr<::grpc::ClientAsyncWriter<::grpc::testing::Request>>
+    PrepareAsyncMethodA2(::grpc::ClientContext* context,
+                         ::grpc::testing::Response* response,
+                         ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr<
+          ::grpc::ClientAsyncWriter<::grpc::testing::Request>>(
+          PrepareAsyncMethodA2Raw(context, response, cq));
+    }
+    std::unique_ptr<::grpc::ClientReader<::grpc::testing::Response>> MethodA3(
+        ::grpc::ClientContext* context,
+        const ::grpc::testing::Request& request) {
+      return std::unique_ptr<::grpc::ClientReader<::grpc::testing::Response>>(
+          MethodA3Raw(context, request));
+    }
+    std::unique_ptr<::grpc::ClientAsyncReader<::grpc::testing::Response>>
+    AsyncMethodA3(::grpc::ClientContext* context,
+                  const ::grpc::testing::Request& request,
+                  ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr<
+          ::grpc::ClientAsyncReader<::grpc::testing::Response>>(
+          AsyncMethodA3Raw(context, request, cq, tag));
+    }
+    std::unique_ptr<::grpc::ClientAsyncReader<::grpc::testing::Response>>
+    PrepareAsyncMethodA3(::grpc::ClientContext* context,
+                         const ::grpc::testing::Request& request,
+                         ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr<
+          ::grpc::ClientAsyncReader<::grpc::testing::Response>>(
+          PrepareAsyncMethodA3Raw(context, request, cq));
+    }
+    std::unique_ptr<::grpc::ClientReaderWriter<::grpc::testing::Request,
+                                               ::grpc::testing::Response>>
+    MethodA4(::grpc::ClientContext* context) {
+      return std::unique_ptr<::grpc::ClientReaderWriter<
+          ::grpc::testing::Request, ::grpc::testing::Response>>(
+          MethodA4Raw(context));
+    }
+    std::unique_ptr<::grpc::ClientAsyncReaderWriter<::grpc::testing::Request,
+                                                    ::grpc::testing::Response>>
+    AsyncMethodA4(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq,
+                  void* tag) {
+      return std::unique_ptr<::grpc::ClientAsyncReaderWriter<
+          ::grpc::testing::Request, ::grpc::testing::Response>>(
+          AsyncMethodA4Raw(context, cq, tag));
+    }
+    std::unique_ptr<::grpc::ClientAsyncReaderWriter<::grpc::testing::Request,
+                                                    ::grpc::testing::Response>>
+    PrepareAsyncMethodA4(::grpc::ClientContext* context,
+                         ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr<::grpc::ClientAsyncReaderWriter<
+          ::grpc::testing::Request, ::grpc::testing::Response>>(
+          PrepareAsyncMethodA4Raw(context, cq));
+    }
+    class experimental_async final
+        : public StubInterface::experimental_async_interface {
      public:
-      void MethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response, std::function<void(::grpc::Status)>) override;
-      ::grpc::experimental::ClientCallbackWriter< ::grpc::testing::Request>* MethodA2(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::experimental::ClientWriteReactor* reactor) override;
-      ::grpc::experimental::ClientCallbackReader< ::grpc::testing::Response>* MethodA3(::grpc::ClientContext* context, ::grpc::testing::Request* request, ::grpc::experimental::ClientReadReactor* reactor) override;
-      ::grpc::experimental::ClientCallbackReaderWriter< ::grpc::testing::Request, ::grpc::testing::Response>* MethodA4(::grpc::ClientContext* context, ::grpc::experimental::ClientBidiReactor* reactor) override;
+      void MethodA1(::grpc::ClientContext* context,
+                    const ::grpc::testing::Request* request,
+                    ::grpc::testing::Response* response,
+                    std::function<void(::grpc::Status)>) override;
+      void MethodA2(
+          ::grpc::ClientContext* context, ::grpc::testing::Response* response,
+          ::grpc::experimental::ClientWriteReactor<::grpc::testing::Request>*
+              reactor) override;
+      void MethodA3(
+          ::grpc::ClientContext* context, ::grpc::testing::Request* request,
+          ::grpc::experimental::ClientReadReactor<::grpc::testing::Response>*
+              reactor) override;
+      void MethodA4(::grpc::ClientContext* context,
+                    ::grpc::experimental::ClientBidiReactor<
+                        ::grpc::testing::Request, ::grpc::testing::Response>*
+                        reactor) override;
+
      private:
       friend class Stub;
-      explicit experimental_async(Stub* stub): stub_(stub) { }
+      explicit experimental_async(Stub* stub) : stub_(stub) {}
       Stub* stub() { return stub_; }
       Stub* stub_;
     };
-    class experimental_async_interface* experimental_async() override { return &async_stub_; }
-
-   private:
-    std::shared_ptr< ::grpc::ChannelInterface> channel_;
-    class experimental_async async_stub_{this};
-    ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>* AsyncMethodA1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) override;
-    ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>* PrepareAsyncMethodA1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) override;
-    ::grpc::ClientWriter< ::grpc::testing::Request>* MethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response) override;
-    ::grpc::ClientAsyncWriter< ::grpc::testing::Request>* AsyncMethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq, void* tag) override;
-    ::grpc::ClientAsyncWriter< ::grpc::testing::Request>* PrepareAsyncMethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq) override;
-    ::grpc::ClientReader< ::grpc::testing::Response>* MethodA3Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request) override;
-    ::grpc::ClientAsyncReader< ::grpc::testing::Response>* AsyncMethodA3Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq, void* tag) override;
-    ::grpc::ClientAsyncReader< ::grpc::testing::Response>* PrepareAsyncMethodA3Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) override;
-    ::grpc::ClientReaderWriter< ::grpc::testing::Request, ::grpc::testing::Response>* MethodA4Raw(::grpc::ClientContext* context) override;
-    ::grpc::ClientAsyncReaderWriter< ::grpc::testing::Request, ::grpc::testing::Response>* AsyncMethodA4Raw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
-    ::grpc::ClientAsyncReaderWriter< ::grpc::testing::Request, ::grpc::testing::Response>* PrepareAsyncMethodA4Raw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
+    class experimental_async_interface* experimental_async() override {
+      return &async_stub_;
+    }
+
+   private:
+    std::shared_ptr<::grpc::ChannelInterface> channel_;
+    class experimental_async async_stub_ {
+      this
+    };
+    ::grpc::ClientAsyncResponseReader<::grpc::testing::Response>*
+    AsyncMethodA1Raw(::grpc::ClientContext* context,
+                     const ::grpc::testing::Request& request,
+                     ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader<::grpc::testing::Response>*
+    PrepareAsyncMethodA1Raw(::grpc::ClientContext* context,
+                            const ::grpc::testing::Request& request,
+                            ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientWriter<::grpc::testing::Request>* MethodA2Raw(
+        ::grpc::ClientContext* context,
+        ::grpc::testing::Response* response) override;
+    ::grpc::ClientAsyncWriter<::grpc::testing::Request>* AsyncMethodA2Raw(
+        ::grpc::ClientContext* context, ::grpc::testing::Response* response,
+        ::grpc::CompletionQueue* cq, void* tag) override;
+    ::grpc::ClientAsyncWriter<::grpc::testing::Request>*
+    PrepareAsyncMethodA2Raw(::grpc::ClientContext* context,
+                            ::grpc::testing::Response* response,
+                            ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientReader<::grpc::testing::Response>* MethodA3Raw(
+        ::grpc::ClientContext* context,
+        const ::grpc::testing::Request& request) override;
+    ::grpc::ClientAsyncReader<::grpc::testing::Response>* AsyncMethodA3Raw(
+        ::grpc::ClientContext* context, const ::grpc::testing::Request& request,
+        ::grpc::CompletionQueue* cq, void* tag) override;
+    ::grpc::ClientAsyncReader<::grpc::testing::Response>*
+    PrepareAsyncMethodA3Raw(::grpc::ClientContext* context,
+                            const ::grpc::testing::Request& request,
+                            ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientReaderWriter<::grpc::testing::Request,
+                               ::grpc::testing::Response>*
+    MethodA4Raw(::grpc::ClientContext* context) override;
+    ::grpc::ClientAsyncReaderWriter<::grpc::testing::Request,
+                                    ::grpc::testing::Response>*
+    AsyncMethodA4Raw(::grpc::ClientContext* context,
+                     ::grpc::CompletionQueue* cq, void* tag) override;
+    ::grpc::ClientAsyncReaderWriter<::grpc::testing::Request,
+                                    ::grpc::testing::Response>*
+    PrepareAsyncMethodA4Raw(::grpc::ClientContext* context,
+                            ::grpc::CompletionQueue* cq) override;
     const ::grpc::internal::RpcMethod rpcmethod_MethodA1_;
     const ::grpc::internal::RpcMethod rpcmethod_MethodA2_;
     const ::grpc::internal::RpcMethod rpcmethod_MethodA3_;
     const ::grpc::internal::RpcMethod rpcmethod_MethodA4_;
   };
-  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
+  static std::unique_ptr<Stub> NewStub(
+      const std::shared_ptr<::grpc::ChannelInterface>& channel,
+      const ::grpc::StubOptions& options = ::grpc::StubOptions());
 
   class Service : public ::grpc::Service {
    public:
     Service();
     virtual ~Service();
     // MethodA1 leading comment 1
-    virtual ::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response);
+    virtual ::grpc::Status MethodA1(::grpc::ServerContext* context,
+                                    const ::grpc::testing::Request* request,
+                                    ::grpc::testing::Response* response);
     // MethodA1 trailing comment 1
     // MethodA2 detached leading comment 1
     //
     // Method A2 leading comment 1
     // Method A2 leading comment 2
-    virtual ::grpc::Status MethodA2(::grpc::ServerContext* context, ::grpc::ServerReader< ::grpc::testing::Request>* reader, ::grpc::testing::Response* response);
+    virtual ::grpc::Status MethodA2(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerReader<::grpc::testing::Request>* reader,
+        ::grpc::testing::Response* response);
     // MethodA2 trailing comment 1
     // Method A3 leading comment 1
-    virtual ::grpc::Status MethodA3(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::ServerWriter< ::grpc::testing::Response>* writer);
+    virtual ::grpc::Status MethodA3(
+        ::grpc::ServerContext* context, const ::grpc::testing::Request* request,
+        ::grpc::ServerWriter<::grpc::testing::Response>* writer);
     // Method A3 trailing comment 1
     // Method A4 leading comment 1
-    virtual ::grpc::Status MethodA4(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::grpc::testing::Response, ::grpc::testing::Request>* stream);
+    virtual ::grpc::Status MethodA4(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerReaderWriter<::grpc::testing::Response,
+                                   ::grpc::testing::Request>* stream);
     // Method A4 trailing comment 1
   };
   template <class BaseClass>
   class WithAsyncMethod_MethodA1 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithAsyncMethod_MethodA1() {
-      ::grpc::Service::MarkMethodAsync(0);
-    }
+    WithAsyncMethod_MethodA1() { ::grpc::Service::MarkMethodAsync(0); }
     ~WithAsyncMethod_MethodA1() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodA1(::grpc::ServerContext* context,
+                            const ::grpc::testing::Request* request,
+                            ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestMethodA1(::grpc::ServerContext* context, ::grpc::testing::Request* request, ::grpc::ServerAsyncResponseWriter< ::grpc::testing::Response>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    void RequestMethodA1(
+        ::grpc::ServerContext* context, ::grpc::testing::Request* request,
+        ::grpc::ServerAsyncResponseWriter<::grpc::testing::Response>* response,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response,
+                                         new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
   class WithAsyncMethod_MethodA2 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithAsyncMethod_MethodA2() {
-      ::grpc::Service::MarkMethodAsync(1);
-    }
+    WithAsyncMethod_MethodA2() { ::grpc::Service::MarkMethodAsync(1); }
     ~WithAsyncMethod_MethodA2() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA2(::grpc::ServerContext* context, ::grpc::ServerReader< ::grpc::testing::Request>* reader, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodA2(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerReader<::grpc::testing::Request>* reader,
+        ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestMethodA2(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::grpc::testing::Response, ::grpc::testing::Request>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncClientStreaming(1, context, reader, new_call_cq, notification_cq, tag);
+    void RequestMethodA2(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerAsyncReader<::grpc::testing::Response,
+                                  ::grpc::testing::Request>* reader,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncClientStreaming(
+          1, context, reader, new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
   class WithAsyncMethod_MethodA3 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithAsyncMethod_MethodA3() {
-      ::grpc::Service::MarkMethodAsync(2);
-    }
+    WithAsyncMethod_MethodA3() { ::grpc::Service::MarkMethodAsync(2); }
     ~WithAsyncMethod_MethodA3() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA3(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::ServerWriter< ::grpc::testing::Response>* writer) override {
+    ::grpc::Status MethodA3(
+        ::grpc::ServerContext* context, const ::grpc::testing::Request* request,
+        ::grpc::ServerWriter<::grpc::testing::Response>* writer) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestMethodA3(::grpc::ServerContext* context, ::grpc::testing::Request* request, ::grpc::ServerAsyncWriter< ::grpc::testing::Response>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncServerStreaming(2, context, request, writer, new_call_cq, notification_cq, tag);
+    void RequestMethodA3(
+        ::grpc::ServerContext* context, ::grpc::testing::Request* request,
+        ::grpc::ServerAsyncWriter<::grpc::testing::Response>* writer,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncServerStreaming(
+          2, context, request, writer, new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
   class WithAsyncMethod_MethodA4 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithAsyncMethod_MethodA4() {
-      ::grpc::Service::MarkMethodAsync(3);
-    }
+    WithAsyncMethod_MethodA4() { ::grpc::Service::MarkMethodAsync(3); }
     ~WithAsyncMethod_MethodA4() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA4(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::grpc::testing::Response, ::grpc::testing::Request>* stream)  override {
+    ::grpc::Status MethodA4(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerReaderWriter<::grpc::testing::Response,
+                                   ::grpc::testing::Request>* stream) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestMethodA4(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::testing::Response, ::grpc::testing::Request>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncBidiStreaming(3, context, stream, new_call_cq, notification_cq, tag);
+    void RequestMethodA4(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerAsyncReaderWriter<::grpc::testing::Response,
+                                        ::grpc::testing::Request>* stream,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncBidiStreaming(
+          3, context, stream, new_call_cq, notification_cq, tag);
     }
   };
-  typedef WithAsyncMethod_MethodA1<WithAsyncMethod_MethodA2<WithAsyncMethod_MethodA3<WithAsyncMethod_MethodA4<Service > > > > AsyncService;
+  typedef WithAsyncMethod_MethodA1<WithAsyncMethod_MethodA2<
+      WithAsyncMethod_MethodA3<WithAsyncMethod_MethodA4<Service>>>>
+      AsyncService;
   template <class BaseClass>
   class ExperimentalWithCallbackMethod_MethodA1 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
     ExperimentalWithCallbackMethod_MethodA1() {
-      ::grpc::Service::experimental().MarkMethodCallback(0,
-        new ::grpc::internal::CallbackUnaryHandler< ExperimentalWithCallbackMethod_MethodA1<BaseClass>, ::grpc::testing::Request, ::grpc::testing::Response>(
-          [this](::grpc::ServerContext* context,
-                 const ::grpc::testing::Request* request,
-                 ::grpc::testing::Response* response,
-                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+      ::grpc::Service::experimental().MarkMethodCallback(
+          0, new ::grpc::internal::CallbackUnaryHandler<
+                 ExperimentalWithCallbackMethod_MethodA1<BaseClass>,
+                 ::grpc::testing::Request, ::grpc::testing::Response>(
+                 [this](::grpc::ServerContext* context,
+                        const ::grpc::testing::Request* request,
+                        ::grpc::testing::Response* response,
+                        ::grpc::experimental::ServerCallbackRpcController*
+                            controller) {
                    this->MethodA1(context, request, response, controller);
-                 }, this));
+                 },
+                 this));
     }
     ~ExperimentalWithCallbackMethod_MethodA1() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodA1(::grpc::ServerContext* context,
+                            const ::grpc::testing::Request* request,
+                            ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    virtual void MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+    virtual void MethodA1(
+        ::grpc::ServerContext* context, const ::grpc::testing::Request* request,
+        ::grpc::testing::Response* response,
+        ::grpc::experimental::ServerCallbackRpcController* controller) {
+      controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""));
+    }
   };
   template <class BaseClass>
   class ExperimentalWithCallbackMethod_MethodA2 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    ExperimentalWithCallbackMethod_MethodA2() {
-    }
+    ExperimentalWithCallbackMethod_MethodA2() {}
     ~ExperimentalWithCallbackMethod_MethodA2() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA2(::grpc::ServerContext* context, ::grpc::ServerReader< ::grpc::testing::Request>* reader, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodA2(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerReader<::grpc::testing::Request>* reader,
+        ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -359,15 +621,17 @@ class ServiceA final {
   template <class BaseClass>
   class ExperimentalWithCallbackMethod_MethodA3 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    ExperimentalWithCallbackMethod_MethodA3() {
-    }
+    ExperimentalWithCallbackMethod_MethodA3() {}
     ~ExperimentalWithCallbackMethod_MethodA3() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA3(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::ServerWriter< ::grpc::testing::Response>* writer) override {
+    ::grpc::Status MethodA3(
+        ::grpc::ServerContext* context, const ::grpc::testing::Request* request,
+        ::grpc::ServerWriter<::grpc::testing::Response>* writer) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -375,33 +639,41 @@ class ServiceA final {
   template <class BaseClass>
   class ExperimentalWithCallbackMethod_MethodA4 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    ExperimentalWithCallbackMethod_MethodA4() {
-    }
+    ExperimentalWithCallbackMethod_MethodA4() {}
     ~ExperimentalWithCallbackMethod_MethodA4() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA4(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::grpc::testing::Response, ::grpc::testing::Request>* stream)  override {
+    ::grpc::Status MethodA4(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerReaderWriter<::grpc::testing::Response,
+                                   ::grpc::testing::Request>* stream) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
   };
-  typedef ExperimentalWithCallbackMethod_MethodA1<ExperimentalWithCallbackMethod_MethodA2<ExperimentalWithCallbackMethod_MethodA3<ExperimentalWithCallbackMethod_MethodA4<Service > > > > ExperimentalCallbackService;
+  typedef ExperimentalWithCallbackMethod_MethodA1<
+      ExperimentalWithCallbackMethod_MethodA2<
+          ExperimentalWithCallbackMethod_MethodA3<
+              ExperimentalWithCallbackMethod_MethodA4<Service>>>>
+      ExperimentalCallbackService;
   template <class BaseClass>
   class WithGenericMethod_MethodA1 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithGenericMethod_MethodA1() {
-      ::grpc::Service::MarkMethodGeneric(0);
-    }
+    WithGenericMethod_MethodA1() { ::grpc::Service::MarkMethodGeneric(0); }
     ~WithGenericMethod_MethodA1() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodA1(::grpc::ServerContext* context,
+                            const ::grpc::testing::Request* request,
+                            ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -409,16 +681,18 @@ class ServiceA final {
   template <class BaseClass>
   class WithGenericMethod_MethodA2 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithGenericMethod_MethodA2() {
-      ::grpc::Service::MarkMethodGeneric(1);
-    }
+    WithGenericMethod_MethodA2() { ::grpc::Service::MarkMethodGeneric(1); }
     ~WithGenericMethod_MethodA2() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA2(::grpc::ServerContext* context, ::grpc::ServerReader< ::grpc::testing::Request>* reader, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodA2(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerReader<::grpc::testing::Request>* reader,
+        ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -426,16 +700,17 @@ class ServiceA final {
   template <class BaseClass>
   class WithGenericMethod_MethodA3 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithGenericMethod_MethodA3() {
-      ::grpc::Service::MarkMethodGeneric(2);
-    }
+    WithGenericMethod_MethodA3() { ::grpc::Service::MarkMethodGeneric(2); }
     ~WithGenericMethod_MethodA3() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA3(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::ServerWriter< ::grpc::testing::Response>* writer) override {
+    ::grpc::Status MethodA3(
+        ::grpc::ServerContext* context, const ::grpc::testing::Request* request,
+        ::grpc::ServerWriter<::grpc::testing::Response>* writer) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -443,16 +718,18 @@ class ServiceA final {
   template <class BaseClass>
   class WithGenericMethod_MethodA4 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithGenericMethod_MethodA4() {
-      ::grpc::Service::MarkMethodGeneric(3);
-    }
+    WithGenericMethod_MethodA4() { ::grpc::Service::MarkMethodGeneric(3); }
     ~WithGenericMethod_MethodA4() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA4(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::grpc::testing::Response, ::grpc::testing::Request>* stream)  override {
+    ::grpc::Status MethodA4(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerReaderWriter<::grpc::testing::Response,
+                                   ::grpc::testing::Request>* stream) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -460,120 +737,164 @@ class ServiceA final {
   template <class BaseClass>
   class WithRawMethod_MethodA1 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithRawMethod_MethodA1() {
-      ::grpc::Service::MarkMethodRaw(0);
-    }
+    WithRawMethod_MethodA1() { ::grpc::Service::MarkMethodRaw(0); }
     ~WithRawMethod_MethodA1() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodA1(::grpc::ServerContext* context,
+                            const ::grpc::testing::Request* request,
+                            ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestMethodA1(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    void RequestMethodA1(
+        ::grpc::ServerContext* context, ::grpc::ByteBuffer* request,
+        ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response,
+                                         new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
   class WithRawMethod_MethodA2 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithRawMethod_MethodA2() {
-      ::grpc::Service::MarkMethodRaw(1);
-    }
+    WithRawMethod_MethodA2() { ::grpc::Service::MarkMethodRaw(1); }
     ~WithRawMethod_MethodA2() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA2(::grpc::ServerContext* context, ::grpc::ServerReader< ::grpc::testing::Request>* reader, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodA2(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerReader<::grpc::testing::Request>* reader,
+        ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestMethodA2(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncClientStreaming(1, context, reader, new_call_cq, notification_cq, tag);
+    void RequestMethodA2(::grpc::ServerContext* context,
+                         ::grpc::ServerAsyncReader<::grpc::ByteBuffer,
+                                                   ::grpc::ByteBuffer>* reader,
+                         ::grpc::CompletionQueue* new_call_cq,
+                         ::grpc::ServerCompletionQueue* notification_cq,
+                         void* tag) {
+      ::grpc::Service::RequestAsyncClientStreaming(
+          1, context, reader, new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
   class WithRawMethod_MethodA3 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithRawMethod_MethodA3() {
-      ::grpc::Service::MarkMethodRaw(2);
-    }
+    WithRawMethod_MethodA3() { ::grpc::Service::MarkMethodRaw(2); }
     ~WithRawMethod_MethodA3() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA3(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::ServerWriter< ::grpc::testing::Response>* writer) override {
+    ::grpc::Status MethodA3(
+        ::grpc::ServerContext* context, const ::grpc::testing::Request* request,
+        ::grpc::ServerWriter<::grpc::testing::Response>* writer) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestMethodA3(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncServerStreaming(2, context, request, writer, new_call_cq, notification_cq, tag);
+    void RequestMethodA3(::grpc::ServerContext* context,
+                         ::grpc::ByteBuffer* request,
+                         ::grpc::ServerAsyncWriter<::grpc::ByteBuffer>* writer,
+                         ::grpc::CompletionQueue* new_call_cq,
+                         ::grpc::ServerCompletionQueue* notification_cq,
+                         void* tag) {
+      ::grpc::Service::RequestAsyncServerStreaming(
+          2, context, request, writer, new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
   class WithRawMethod_MethodA4 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithRawMethod_MethodA4() {
-      ::grpc::Service::MarkMethodRaw(3);
-    }
+    WithRawMethod_MethodA4() { ::grpc::Service::MarkMethodRaw(3); }
     ~WithRawMethod_MethodA4() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA4(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::grpc::testing::Response, ::grpc::testing::Request>* stream)  override {
+    ::grpc::Status MethodA4(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerReaderWriter<::grpc::testing::Response,
+                                   ::grpc::testing::Request>* stream) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestMethodA4(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncBidiStreaming(3, context, stream, new_call_cq, notification_cq, tag);
+    void RequestMethodA4(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerAsyncReaderWriter<::grpc::ByteBuffer, ::grpc::ByteBuffer>*
+            stream,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncBidiStreaming(
+          3, context, stream, new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
   class ExperimentalWithRawCallbackMethod_MethodA1 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
     ExperimentalWithRawCallbackMethod_MethodA1() {
-      ::grpc::Service::experimental().MarkMethodRawCallback(0,
-        new ::grpc::internal::CallbackUnaryHandler< ExperimentalWithRawCallbackMethod_MethodA1<BaseClass>, ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
-          [this](::grpc::ServerContext* context,
-                 const ::grpc::ByteBuffer* request,
-                 ::grpc::ByteBuffer* response,
-                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+      ::grpc::Service::experimental().MarkMethodRawCallback(
+          0, new ::grpc::internal::CallbackUnaryHandler<
+                 ExperimentalWithRawCallbackMethod_MethodA1<BaseClass>,
+                 ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+                 [this](::grpc::ServerContext* context,
+                        const ::grpc::ByteBuffer* request,
+                        ::grpc::ByteBuffer* response,
+                        ::grpc::experimental::ServerCallbackRpcController*
+                            controller) {
                    this->MethodA1(context, request, response, controller);
-                 }, this));
+                 },
+                 this));
     }
     ~ExperimentalWithRawCallbackMethod_MethodA1() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodA1(::grpc::ServerContext* context,
+                            const ::grpc::testing::Request* request,
+                            ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    virtual void MethodA1(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+    virtual void MethodA1(
+        ::grpc::ServerContext* context, const ::grpc::ByteBuffer* request,
+        ::grpc::ByteBuffer* response,
+        ::grpc::experimental::ServerCallbackRpcController* controller) {
+      controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""));
+    }
   };
   template <class BaseClass>
   class ExperimentalWithRawCallbackMethod_MethodA2 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    ExperimentalWithRawCallbackMethod_MethodA2() {
-    }
+    ExperimentalWithRawCallbackMethod_MethodA2() {}
     ~ExperimentalWithRawCallbackMethod_MethodA2() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA2(::grpc::ServerContext* context, ::grpc::ServerReader< ::grpc::testing::Request>* reader, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodA2(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerReader<::grpc::testing::Request>* reader,
+        ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -581,15 +902,17 @@ class ServiceA final {
   template <class BaseClass>
   class ExperimentalWithRawCallbackMethod_MethodA3 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    ExperimentalWithRawCallbackMethod_MethodA3() {
-    }
+    ExperimentalWithRawCallbackMethod_MethodA3() {}
     ~ExperimentalWithRawCallbackMethod_MethodA3() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA3(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::ServerWriter< ::grpc::testing::Response>* writer) override {
+    ::grpc::Status MethodA3(
+        ::grpc::ServerContext* context, const ::grpc::testing::Request* request,
+        ::grpc::ServerWriter<::grpc::testing::Response>* writer) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -597,15 +920,18 @@ class ServiceA final {
   template <class BaseClass>
   class ExperimentalWithRawCallbackMethod_MethodA4 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    ExperimentalWithRawCallbackMethod_MethodA4() {
-    }
+    ExperimentalWithRawCallbackMethod_MethodA4() {}
     ~ExperimentalWithRawCallbackMethod_MethodA4() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodA4(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::grpc::testing::Response, ::grpc::testing::Request>* stream)  override {
+    ::grpc::Status MethodA4(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerReaderWriter<::grpc::testing::Response,
+                                   ::grpc::testing::Request>* stream) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -613,46 +939,69 @@ class ServiceA final {
   template <class BaseClass>
   class WithStreamedUnaryMethod_MethodA1 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
     WithStreamedUnaryMethod_MethodA1() {
-      ::grpc::Service::MarkMethodStreamed(0,
-        new ::grpc::internal::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithStreamedUnaryMethod_MethodA1<BaseClass>::StreamedMethodA1, this, std::placeholders::_1, std::placeholders::_2)));
+      ::grpc::Service::MarkMethodStreamed(
+          0, new ::grpc::internal::StreamedUnaryHandler<
+                 ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(
+                 &WithStreamedUnaryMethod_MethodA1<BaseClass>::StreamedMethodA1,
+                 this, std::placeholders::_1, std::placeholders::_2)));
     }
     ~WithStreamedUnaryMethod_MethodA1() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable regular version of this method
-    ::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodA1(::grpc::ServerContext* context,
+                            const ::grpc::testing::Request* request,
+                            ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
     // replace default version of method with streamed unary
-    virtual ::grpc::Status StreamedMethodA1(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::grpc::testing::Request,::grpc::testing::Response>* server_unary_streamer) = 0;
+    virtual ::grpc::Status StreamedMethodA1(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerUnaryStreamer<::grpc::testing::Request,
+                                    ::grpc::testing::Response>*
+            server_unary_streamer) = 0;
   };
-  typedef WithStreamedUnaryMethod_MethodA1<Service > StreamedUnaryService;
+  typedef WithStreamedUnaryMethod_MethodA1<Service> StreamedUnaryService;
   template <class BaseClass>
   class WithSplitStreamingMethod_MethodA3 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
     WithSplitStreamingMethod_MethodA3() {
-      ::grpc::Service::MarkMethodStreamed(2,
-        new ::grpc::internal::SplitServerStreamingHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithSplitStreamingMethod_MethodA3<BaseClass>::StreamedMethodA3, this, std::placeholders::_1, std::placeholders::_2)));
+      ::grpc::Service::MarkMethodStreamed(
+          2,
+          new ::grpc::internal::SplitServerStreamingHandler<
+              ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(
+              &WithSplitStreamingMethod_MethodA3<BaseClass>::StreamedMethodA3,
+              this, std::placeholders::_1, std::placeholders::_2)));
     }
     ~WithSplitStreamingMethod_MethodA3() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable regular version of this method
-    ::grpc::Status MethodA3(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::ServerWriter< ::grpc::testing::Response>* writer) override {
+    ::grpc::Status MethodA3(
+        ::grpc::ServerContext* context, const ::grpc::testing::Request* request,
+        ::grpc::ServerWriter<::grpc::testing::Response>* writer) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
     // replace default version of method with split streamed
-    virtual ::grpc::Status StreamedMethodA3(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::grpc::testing::Request,::grpc::testing::Response>* server_split_streamer) = 0;
+    virtual ::grpc::Status StreamedMethodA3(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerSplitStreamer<::grpc::testing::Request,
+                                    ::grpc::testing::Response>*
+            server_split_streamer) = 0;
   };
-  typedef WithSplitStreamingMethod_MethodA3<Service > SplitStreamedService;
-  typedef WithStreamedUnaryMethod_MethodA1<WithSplitStreamingMethod_MethodA3<Service > > StreamedService;
+  typedef WithSplitStreamingMethod_MethodA3<Service> SplitStreamedService;
+  typedef WithStreamedUnaryMethod_MethodA1<
+      WithSplitStreamingMethod_MethodA3<Service>>
+      StreamedService;
 };
 
 // ServiceB leading comment 1
@@ -665,125 +1014,204 @@ class ServiceB final {
    public:
     virtual ~StubInterface() {}
     // MethodB1 leading comment 1
-    virtual ::grpc::Status MethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::testing::Response* response) = 0;
-    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>> AsyncMethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>>(AsyncMethodB1Raw(context, request, cq));
-    }
-    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>> PrepareAsyncMethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>>(PrepareAsyncMethodB1Raw(context, request, cq));
+    virtual ::grpc::Status MethodB1(::grpc::ClientContext* context,
+                                    const ::grpc::testing::Request& request,
+                                    ::grpc::testing::Response* response) = 0;
+    std::unique_ptr<
+        ::grpc::ClientAsyncResponseReaderInterface<::grpc::testing::Response>>
+    AsyncMethodB1(::grpc::ClientContext* context,
+                  const ::grpc::testing::Request& request,
+                  ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<
+          ::grpc::testing::Response>>(AsyncMethodB1Raw(context, request, cq));
+    }
+    std::unique_ptr<
+        ::grpc::ClientAsyncResponseReaderInterface<::grpc::testing::Response>>
+    PrepareAsyncMethodB1(::grpc::ClientContext* context,
+                         const ::grpc::testing::Request& request,
+                         ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<
+          ::grpc::testing::Response>>(
+          PrepareAsyncMethodB1Raw(context, request, cq));
     }
     // MethodB1 trailing comment 1
     class experimental_async_interface {
      public:
       virtual ~experimental_async_interface() {}
       // MethodB1 leading comment 1
-      virtual void MethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void MethodB1(::grpc::ClientContext* context,
+                            const ::grpc::testing::Request* request,
+                            ::grpc::testing::Response* response,
+                            std::function<void(::grpc::Status)>) = 0;
       // MethodB1 trailing comment 1
     };
-    virtual class experimental_async_interface* experimental_async() { return nullptr; }
-  private:
-    virtual ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>* AsyncMethodB1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) = 0;
-    virtual ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>* PrepareAsyncMethodB1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual class experimental_async_interface* experimental_async() {
+      return nullptr;
+    }
+
+   private:
+    virtual ::grpc::ClientAsyncResponseReaderInterface<
+        ::grpc::testing::Response>*
+    AsyncMethodB1Raw(::grpc::ClientContext* context,
+                     const ::grpc::testing::Request& request,
+                     ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface<
+        ::grpc::testing::Response>*
+    PrepareAsyncMethodB1Raw(::grpc::ClientContext* context,
+                            const ::grpc::testing::Request& request,
+                            ::grpc::CompletionQueue* cq) = 0;
   };
   class Stub final : public StubInterface {
    public:
-    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel);
-    ::grpc::Status MethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::testing::Response* response) override;
-    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>> AsyncMethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>>(AsyncMethodB1Raw(context, request, cq));
-    }
-    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>> PrepareAsyncMethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>>(PrepareAsyncMethodB1Raw(context, request, cq));
-    }
-    class experimental_async final :
-      public StubInterface::experimental_async_interface {
+    Stub(const std::shared_ptr<::grpc::ChannelInterface>& channel);
+    ::grpc::Status MethodB1(::grpc::ClientContext* context,
+                            const ::grpc::testing::Request& request,
+                            ::grpc::testing::Response* response) override;
+    std::unique_ptr<
+        ::grpc::ClientAsyncResponseReader<::grpc::testing::Response>>
+    AsyncMethodB1(::grpc::ClientContext* context,
+                  const ::grpc::testing::Request& request,
+                  ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr<
+          ::grpc::ClientAsyncResponseReader<::grpc::testing::Response>>(
+          AsyncMethodB1Raw(context, request, cq));
+    }
+    std::unique_ptr<
+        ::grpc::ClientAsyncResponseReader<::grpc::testing::Response>>
+    PrepareAsyncMethodB1(::grpc::ClientContext* context,
+                         const ::grpc::testing::Request& request,
+                         ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr<
+          ::grpc::ClientAsyncResponseReader<::grpc::testing::Response>>(
+          PrepareAsyncMethodB1Raw(context, request, cq));
+    }
+    class experimental_async final
+        : public StubInterface::experimental_async_interface {
      public:
-      void MethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response, std::function<void(::grpc::Status)>) override;
+      void MethodB1(::grpc::ClientContext* context,
+                    const ::grpc::testing::Request* request,
+                    ::grpc::testing::Response* response,
+                    std::function<void(::grpc::Status)>) override;
+
      private:
       friend class Stub;
-      explicit experimental_async(Stub* stub): stub_(stub) { }
+      explicit experimental_async(Stub* stub) : stub_(stub) {}
       Stub* stub() { return stub_; }
       Stub* stub_;
     };
-    class experimental_async_interface* experimental_async() override { return &async_stub_; }
+    class experimental_async_interface* experimental_async() override {
+      return &async_stub_;
+    }
 
    private:
-    std::shared_ptr< ::grpc::ChannelInterface> channel_;
-    class experimental_async async_stub_{this};
-    ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>* AsyncMethodB1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) override;
-    ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>* PrepareAsyncMethodB1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) override;
+    std::shared_ptr<::grpc::ChannelInterface> channel_;
+    class experimental_async async_stub_ {
+      this
+    };
+    ::grpc::ClientAsyncResponseReader<::grpc::testing::Response>*
+    AsyncMethodB1Raw(::grpc::ClientContext* context,
+                     const ::grpc::testing::Request& request,
+                     ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader<::grpc::testing::Response>*
+    PrepareAsyncMethodB1Raw(::grpc::ClientContext* context,
+                            const ::grpc::testing::Request& request,
+                            ::grpc::CompletionQueue* cq) override;
     const ::grpc::internal::RpcMethod rpcmethod_MethodB1_;
   };
-  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
+  static std::unique_ptr<Stub> NewStub(
+      const std::shared_ptr<::grpc::ChannelInterface>& channel,
+      const ::grpc::StubOptions& options = ::grpc::StubOptions());
 
   class Service : public ::grpc::Service {
    public:
     Service();
     virtual ~Service();
     // MethodB1 leading comment 1
-    virtual ::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response);
+    virtual ::grpc::Status MethodB1(::grpc::ServerContext* context,
+                                    const ::grpc::testing::Request* request,
+                                    ::grpc::testing::Response* response);
     // MethodB1 trailing comment 1
   };
   template <class BaseClass>
   class WithAsyncMethod_MethodB1 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithAsyncMethod_MethodB1() {
-      ::grpc::Service::MarkMethodAsync(0);
-    }
+    WithAsyncMethod_MethodB1() { ::grpc::Service::MarkMethodAsync(0); }
     ~WithAsyncMethod_MethodB1() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodB1(::grpc::ServerContext* context,
+                            const ::grpc::testing::Request* request,
+                            ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestMethodB1(::grpc::ServerContext* context, ::grpc::testing::Request* request, ::grpc::ServerAsyncResponseWriter< ::grpc::testing::Response>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    void RequestMethodB1(
+        ::grpc::ServerContext* context, ::grpc::testing::Request* request,
+        ::grpc::ServerAsyncResponseWriter<::grpc::testing::Response>* response,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response,
+                                         new_call_cq, notification_cq, tag);
     }
   };
-  typedef WithAsyncMethod_MethodB1<Service > AsyncService;
+  typedef WithAsyncMethod_MethodB1<Service> AsyncService;
   template <class BaseClass>
   class ExperimentalWithCallbackMethod_MethodB1 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
     ExperimentalWithCallbackMethod_MethodB1() {
-      ::grpc::Service::experimental().MarkMethodCallback(0,
-        new ::grpc::internal::CallbackUnaryHandler< ExperimentalWithCallbackMethod_MethodB1<BaseClass>, ::grpc::testing::Request, ::grpc::testing::Response>(
-          [this](::grpc::ServerContext* context,
-                 const ::grpc::testing::Request* request,
-                 ::grpc::testing::Response* response,
-                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+      ::grpc::Service::experimental().MarkMethodCallback(
+          0, new ::grpc::internal::CallbackUnaryHandler<
+                 ExperimentalWithCallbackMethod_MethodB1<BaseClass>,
+                 ::grpc::testing::Request, ::grpc::testing::Response>(
+                 [this](::grpc::ServerContext* context,
+                        const ::grpc::testing::Request* request,
+                        ::grpc::testing::Response* response,
+                        ::grpc::experimental::ServerCallbackRpcController*
+                            controller) {
                    this->MethodB1(context, request, response, controller);
-                 }, this));
+                 },
+                 this));
     }
     ~ExperimentalWithCallbackMethod_MethodB1() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodB1(::grpc::ServerContext* context,
+                            const ::grpc::testing::Request* request,
+                            ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    virtual void MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+    virtual void MethodB1(
+        ::grpc::ServerContext* context, const ::grpc::testing::Request* request,
+        ::grpc::testing::Response* response,
+        ::grpc::experimental::ServerCallbackRpcController* controller) {
+      controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""));
+    }
   };
-  typedef ExperimentalWithCallbackMethod_MethodB1<Service > ExperimentalCallbackService;
+  typedef ExperimentalWithCallbackMethod_MethodB1<Service>
+      ExperimentalCallbackService;
   template <class BaseClass>
   class WithGenericMethod_MethodB1 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithGenericMethod_MethodB1() {
-      ::grpc::Service::MarkMethodGeneric(0);
-    }
+    WithGenericMethod_MethodB1() { ::grpc::Service::MarkMethodGeneric(0); }
     ~WithGenericMethod_MethodB1() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodB1(::grpc::ServerContext* context,
+                            const ::grpc::testing::Request* request,
+                            ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -791,76 +1219,103 @@ class ServiceB final {
   template <class BaseClass>
   class WithRawMethod_MethodB1 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
-    WithRawMethod_MethodB1() {
-      ::grpc::Service::MarkMethodRaw(0);
-    }
+    WithRawMethod_MethodB1() { ::grpc::Service::MarkMethodRaw(0); }
     ~WithRawMethod_MethodB1() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodB1(::grpc::ServerContext* context,
+                            const ::grpc::testing::Request* request,
+                            ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestMethodB1(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    void RequestMethodB1(
+        ::grpc::ServerContext* context, ::grpc::ByteBuffer* request,
+        ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response,
+                                         new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
   class ExperimentalWithRawCallbackMethod_MethodB1 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
     ExperimentalWithRawCallbackMethod_MethodB1() {
-      ::grpc::Service::experimental().MarkMethodRawCallback(0,
-        new ::grpc::internal::CallbackUnaryHandler< ExperimentalWithRawCallbackMethod_MethodB1<BaseClass>, ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
-          [this](::grpc::ServerContext* context,
-                 const ::grpc::ByteBuffer* request,
-                 ::grpc::ByteBuffer* response,
-                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+      ::grpc::Service::experimental().MarkMethodRawCallback(
+          0, new ::grpc::internal::CallbackUnaryHandler<
+                 ExperimentalWithRawCallbackMethod_MethodB1<BaseClass>,
+                 ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+                 [this](::grpc::ServerContext* context,
+                        const ::grpc::ByteBuffer* request,
+                        ::grpc::ByteBuffer* response,
+                        ::grpc::experimental::ServerCallbackRpcController*
+                            controller) {
                    this->MethodB1(context, request, response, controller);
-                 }, this));
+                 },
+                 this));
     }
     ~ExperimentalWithRawCallbackMethod_MethodB1() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodB1(::grpc::ServerContext* context,
+                            const ::grpc::testing::Request* request,
+                            ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    virtual void MethodB1(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+    virtual void MethodB1(
+        ::grpc::ServerContext* context, const ::grpc::ByteBuffer* request,
+        ::grpc::ByteBuffer* response,
+        ::grpc::experimental::ServerCallbackRpcController* controller) {
+      controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""));
+    }
   };
   template <class BaseClass>
   class WithStreamedUnaryMethod_MethodB1 : public BaseClass {
    private:
-    void BaseClassMustBeDerivedFromService(const Service *service) {}
+    void BaseClassMustBeDerivedFromService(const Service* service) {}
+
    public:
     WithStreamedUnaryMethod_MethodB1() {
-      ::grpc::Service::MarkMethodStreamed(0,
-        new ::grpc::internal::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithStreamedUnaryMethod_MethodB1<BaseClass>::StreamedMethodB1, this, std::placeholders::_1, std::placeholders::_2)));
+      ::grpc::Service::MarkMethodStreamed(
+          0, new ::grpc::internal::StreamedUnaryHandler<
+                 ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(
+                 &WithStreamedUnaryMethod_MethodB1<BaseClass>::StreamedMethodB1,
+                 this, std::placeholders::_1, std::placeholders::_2)));
     }
     ~WithStreamedUnaryMethod_MethodB1() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable regular version of this method
-    ::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) override {
+    ::grpc::Status MethodB1(::grpc::ServerContext* context,
+                            const ::grpc::testing::Request* request,
+                            ::grpc::testing::Response* response) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
     // replace default version of method with streamed unary
-    virtual ::grpc::Status StreamedMethodB1(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::grpc::testing::Request,::grpc::testing::Response>* server_unary_streamer) = 0;
+    virtual ::grpc::Status StreamedMethodB1(
+        ::grpc::ServerContext* context,
+        ::grpc::ServerUnaryStreamer<::grpc::testing::Request,
+                                    ::grpc::testing::Response>*
+            server_unary_streamer) = 0;
   };
-  typedef WithStreamedUnaryMethod_MethodB1<Service > StreamedUnaryService;
+  typedef WithStreamedUnaryMethod_MethodB1<Service> StreamedUnaryService;
   typedef Service SplitStreamedService;
-  typedef WithStreamedUnaryMethod_MethodB1<Service > StreamedService;
+  typedef WithStreamedUnaryMethod_MethodB1<Service> StreamedService;
 };
 // ServiceB trailing comment 1
 
 }  // namespace testing
 }  // namespace grpc
 
-
 #endif  // GRPC_src_2fproto_2fgrpc_2ftesting_2fcompiler_5ftest_2eproto__INCLUDED