Merge pull request #19788 from chrisse74/master

remove all unused-parameter warnings in C++
5 years ago · 311bf04ec9
parent 297f21d884 33b8b3f998
commit 311bf04ec9
19 changed files with 191 additions and 184 deletions
--- a/include/grpcpp/impl/codegen/async_generic_service.h
+++ b/include/grpcpp/impl/codegen/async_generic_service.h
@ -100,7 +100,7 @@ class ServerGenericBidiReactor
  /// Similar to ServerBidiReactor::OnStarted except for argument type.
  ///
  /// \param[in] context The context object associated with this RPC.
-  virtual void OnStarted(GenericServerContext* context) {}
+  virtual void OnStarted(GenericServerContext* /*context*/) {}

 private:
  void OnStarted(::grpc_impl::ServerContext* ctx) final {
--- a/include/grpcpp/impl/codegen/async_stream_impl.h
+++ b/include/grpcpp/impl/codegen/async_stream_impl.h
@ -197,7 +197,7 @@ template <class R>
 class ClientAsyncReader final : public ClientAsyncReaderInterface<R> {
 public:
  // always allocated against a call arena, no memory free required
-  static void operator delete(void* ptr, std::size_t size) {
+  static void operator delete(void* /*ptr*/, std::size_t size) {
    assert(size == sizeof(ClientAsyncReader));
  }

@ -346,7 +346,7 @@ template <class W>
 class ClientAsyncWriter final : public ClientAsyncWriterInterface<W> {
 public:
  // always allocated against a call arena, no memory free required
-  static void operator delete(void* ptr, std::size_t size) {
+  static void operator delete(void* /*ptr*/, std::size_t size) {
    assert(size == sizeof(ClientAsyncWriter));
  }

@ -514,7 +514,7 @@ class ClientAsyncReaderWriter final
    : public ClientAsyncReaderWriterInterface<W, R> {
 public:
  // always allocated against a call arena, no memory free required
-  static void operator delete(void* ptr, std::size_t size) {
+  static void operator delete(void* /*ptr*/, std::size_t size) {
    assert(size == sizeof(ClientAsyncReaderWriter));
  }

--- a/include/grpcpp/impl/codegen/async_unary_call_impl.h
+++ b/include/grpcpp/impl/codegen/async_unary_call_impl.h
@ -96,7 +96,7 @@ class ClientAsyncResponseReader final
    : public ClientAsyncResponseReaderInterface<R> {
 public:
  // always allocated against a call arena, no memory free required
-  static void operator delete(void* ptr, std::size_t size) {
+  static void operator delete(void* /*ptr*/, std::size_t size) {
    assert(size == sizeof(ClientAsyncResponseReader));
  }

@ -178,7 +178,7 @@ class ClientAsyncResponseReader final

  // disable operator new
  static void* operator new(std::size_t size);
-  static void* operator new(std::size_t size, void* p) { return p; }
+  static void* operator new(std::size_t /*size*/, void* p) { return p; }

  ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata,
                              ::grpc::internal::CallOpSendMessage,
@ -303,12 +303,12 @@ namespace std {
 template <class R>
 class default_delete<::grpc_impl::ClientAsyncResponseReader<R>> {
 public:
-  void operator()(void* p) {}
+  void operator()(void* /*p*/) {}
 };
 template <class R>
 class default_delete<::grpc_impl::ClientAsyncResponseReaderInterface<R>> {
 public:
-  void operator()(void* p) {}
+  void operator()(void* /*p*/) {}
 };
 }  // namespace std

--- a/include/grpcpp/impl/codegen/call_op_set.h
+++ b/include/grpcpp/impl/codegen/call_op_set.h
@ -206,13 +206,14 @@ namespace internal {
 template <int I>
 class CallNoOp {
 protected:
-  void AddOp(grpc_op* ops, size_t* nops) {}
-  void FinishOp(bool* status) {}
+  void AddOp(grpc_op* /*ops*/, size_t* /*nops*/) {}
+  void FinishOp(bool* /*status*/) {}
  void SetInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {}
+      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
  void SetFinishInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {}
-  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {}
+      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
+  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
+  }
 };

 class CallOpSendInitialMetadata {
@ -252,7 +253,7 @@ class CallOpSendInitialMetadata {
          maybe_compression_level_.level;
    }
  }
-  void FinishOp(bool* status) {
+  void FinishOp(bool* /*status*/) {
    if (!send_ || hijacked_) return;
    g_core_codegen_interface->gpr_free(initial_metadata_);
    send_ = false;
@ -267,9 +268,9 @@ class CallOpSendInitialMetadata {
  }

  void SetFinishInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {}
+      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}

-  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
+  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
    hijacked_ = true;
  }

@ -363,7 +364,7 @@ class CallOpSendMessage {
                                        nullptr);
  }

-  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
+  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
    hijacked_ = true;
  }

@ -605,7 +606,7 @@ class CallOpClientSendClose {
    op->flags = 0;
    op->reserved = NULL;
  }
-  void FinishOp(bool* status) { send_ = false; }
+  void FinishOp(bool* /*status*/) { send_ = false; }

  void SetInterceptionHookPoint(
      InterceptorBatchMethodsImpl* interceptor_methods) {
@ -615,9 +616,9 @@ class CallOpClientSendClose {
  }

  void SetFinishInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {}
+      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}

-  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
+  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
    hijacked_ = true;
  }

@ -658,7 +659,7 @@ class CallOpServerSendStatus {
    op->reserved = NULL;
  }

-  void FinishOp(bool* status) {
+  void FinishOp(bool* /*status*/) {
    if (!send_status_available_ || hijacked_) return;
    g_core_codegen_interface->gpr_free(trailing_metadata_);
    send_status_available_ = false;
@ -675,9 +676,9 @@ class CallOpServerSendStatus {
  }

  void SetFinishInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {}
+      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}

-  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
+  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
    hijacked_ = true;
  }

@ -712,7 +713,7 @@ class CallOpRecvInitialMetadata {
    op->reserved = NULL;
  }

-  void FinishOp(bool* status) {
+  void FinishOp(bool* /*status*/) {
    if (metadata_map_ == nullptr || hijacked_) return;
  }

@ -766,7 +767,7 @@ class CallOpClientRecvStatus {
    op->reserved = NULL;
  }

-  void FinishOp(bool* status) {
+  void FinishOp(bool* /*status*/) {
    if (recv_status_ == nullptr || hijacked_) return;
    grpc::string binary_error_details = metadata_map_->GetBinaryErrorDetails();
    *recv_status_ =
--- a/include/grpcpp/impl/codegen/callback_common.h
+++ b/include/grpcpp/impl/codegen/callback_common.h
@ -69,7 +69,7 @@ class CallbackWithStatusTag
    : public grpc_experimental_completion_queue_functor {
 public:
  // always allocated against a call arena, no memory free required
-  static void operator delete(void* ptr, std::size_t size) {
+  static void operator delete(void* /*ptr*/, std::size_t size) {
    assert(size == sizeof(CallbackWithStatusTag));
  }

@ -133,7 +133,7 @@ class CallbackWithSuccessTag
    : public grpc_experimental_completion_queue_functor {
 public:
  // always allocated against a call arena, no memory free required
-  static void operator delete(void* ptr, std::size_t size) {
+  static void operator delete(void* /*ptr*/, std::size_t size) {
    assert(size == sizeof(CallbackWithSuccessTag));
  }

--- a/include/grpcpp/impl/codegen/channel_interface.h
+++ b/include/grpcpp/impl/codegen/channel_interface.h
@ -154,10 +154,10 @@ class ChannelInterface {
  // Returns an empty Call object (rather than being pure) since this is a new
  // method and adding a new pure method to an interface would be a breaking
  // change (even though this is private and non-API)
-  virtual internal::Call CreateCallInternal(const internal::RpcMethod& method,
-                                            ::grpc_impl::ClientContext* context,
-                                            ::grpc_impl::CompletionQueue* cq,
-                                            size_t interceptor_pos) {
+  virtual internal::Call CreateCallInternal(
+      const internal::RpcMethod& /*method*/,
+      ::grpc_impl::ClientContext* /*context*/,
+      ::grpc_impl::CompletionQueue* /*cq*/, size_t /*interceptor_pos*/) {
    return internal::Call();
  }

--- a/include/grpcpp/impl/codegen/client_callback_impl.h
+++ b/include/grpcpp/impl/codegen/client_callback_impl.h
@ -272,7 +272,7 @@ class ClientBidiReactor {
  /// have completed and provides the RPC status outcome.
  ///
  /// \param[in] s The status outcome of this RPC
-  virtual void OnDone(const ::grpc::Status& s) {}
+  virtual void OnDone(const ::grpc::Status& /*s*/) {}

  /// Notifies the application that a read of initial metadata from the
  /// server is done. If the application chooses not to implement this method,
@ -281,19 +281,19 @@ class ClientBidiReactor {
  ///
  /// \param[in] ok Was the initial metadata read successfully? If false, no
  ///               further read-side operation will succeed.
-  virtual void OnReadInitialMetadataDone(bool ok) {}
+  virtual void OnReadInitialMetadataDone(bool /*ok*/) {}

  /// Notifies the application that a StartRead operation completed.
  ///
  /// \param[in] ok Was it successful? If false, no further read-side operation
  ///               will succeed.
-  virtual void OnReadDone(bool ok) {}
+  virtual void OnReadDone(bool /*ok*/) {}

  /// Notifies the application that a StartWrite operation completed.
  ///
  /// \param[in] ok Was it successful? If false, no further write-side operation
  ///               will succeed.
-  virtual void OnWriteDone(bool ok) {}
+  virtual void OnWriteDone(bool /*ok*/) {}

  /// Notifies the application that a StartWritesDone operation completed. Note
  /// that this is only used on explicit StartWritesDone operations and not for
@ -301,7 +301,7 @@ class ClientBidiReactor {
  ///
  /// \param[in] ok Was it successful? If false, the application will later see
  ///               the failure reflected as a bad status in OnDone.
-  virtual void OnWritesDoneDone(bool ok) {}
+  virtual void OnWritesDoneDone(bool /*ok*/) {}

 private:
  friend class ClientCallbackReaderWriter<Request, Response>;
@ -325,9 +325,9 @@ class ClientReadReactor {
  void AddMultipleHolds(int holds) { reader_->AddHold(holds); }
  void RemoveHold() { reader_->RemoveHold(); }

-  virtual void OnDone(const ::grpc::Status& s) {}
-  virtual void OnReadInitialMetadataDone(bool ok) {}
-  virtual void OnReadDone(bool ok) {}
+  virtual void OnDone(const ::grpc::Status& /*s*/) {}
+  virtual void OnReadInitialMetadataDone(bool /*ok*/) {}
+  virtual void OnReadDone(bool /*ok*/) {}

 private:
  friend class ClientCallbackReader<Response>;
@ -358,10 +358,10 @@ class ClientWriteReactor {
  void AddMultipleHolds(int holds) { writer_->AddHold(holds); }
  void RemoveHold() { writer_->RemoveHold(); }

-  virtual void OnDone(const ::grpc::Status& s) {}
-  virtual void OnReadInitialMetadataDone(bool ok) {}
-  virtual void OnWriteDone(bool ok) {}
-  virtual void OnWritesDoneDone(bool ok) {}
+  virtual void OnDone(const ::grpc::Status& /*s*/) {}
+  virtual void OnReadInitialMetadataDone(bool /*ok*/) {}
+  virtual void OnWriteDone(bool /*ok*/) {}
+  virtual void OnWritesDoneDone(bool /*ok*/) {}

 private:
  friend class ClientCallbackWriter<Request>;
@ -385,8 +385,8 @@ class ClientUnaryReactor {
  virtual ~ClientUnaryReactor() {}

  void StartCall() { call_->StartCall(); }
-  virtual void OnDone(const ::grpc::Status& s) {}
-  virtual void OnReadInitialMetadataDone(bool ok) {}
+  virtual void OnDone(const ::grpc::Status& /*s*/) {}
+  virtual void OnReadInitialMetadataDone(bool /*ok*/) {}

 private:
  friend class ClientCallbackUnary;
@ -416,7 +416,7 @@ class ClientCallbackReaderWriterImpl
    : public experimental::ClientCallbackReaderWriter<Request, Response> {
 public:
  // always allocated against a call arena, no memory free required
-  static void operator delete(void* ptr, std::size_t size) {
+  static void operator delete(void* /*ptr*/, std::size_t size) {
    assert(size == sizeof(ClientCallbackReaderWriterImpl));
  }

@ -490,7 +490,7 @@ class ClientCallbackReaderWriterImpl
      call_.PerformOps(&writes_done_ops_);
    }

-    finish_tag_.Set(call_.call(), [this](bool ok) { MaybeFinish(); },
+    finish_tag_.Set(call_.call(), [this](bool /*ok*/) { MaybeFinish(); },
                    &finish_ops_);
    finish_ops_.ClientRecvStatus(context_, &finish_status_);
    finish_ops_.set_core_cq_tag(&finish_tag_);
@ -628,7 +628,7 @@ class ClientCallbackReaderImpl
    : public experimental::ClientCallbackReader<Response> {
 public:
  // always allocated against a call arena, no memory free required
-  static void operator delete(void* ptr, std::size_t size) {
+  static void operator delete(void* /*ptr*/, std::size_t size) {
    assert(size == sizeof(ClientCallbackReaderImpl));
  }

@ -682,7 +682,7 @@ class ClientCallbackReaderImpl
      call_.PerformOps(&read_ops_);
    }

-    finish_tag_.Set(call_.call(), [this](bool ok) { MaybeFinish(); },
+    finish_tag_.Set(call_.call(), [this](bool /*ok*/) { MaybeFinish(); },
                    &finish_ops_);
    finish_ops_.ClientRecvStatus(context_, &finish_status_);
    finish_ops_.set_core_cq_tag(&finish_tag_);
@ -768,7 +768,7 @@ class ClientCallbackWriterImpl
    : public experimental::ClientCallbackWriter<Request> {
 public:
  // always allocated against a call arena, no memory free required
-  static void operator delete(void* ptr, std::size_t size) {
+  static void operator delete(void* /*ptr*/, std::size_t size) {
    assert(size == sizeof(ClientCallbackWriterImpl));
  }

@ -830,7 +830,7 @@ class ClientCallbackWriterImpl
      call_.PerformOps(&writes_done_ops_);
    }

-    finish_tag_.Set(call_.call(), [this](bool ok) { MaybeFinish(); },
+    finish_tag_.Set(call_.call(), [this](bool /*ok*/) { MaybeFinish(); },
                    &finish_ops_);
    finish_ops_.ClientRecvStatus(context_, &finish_status_);
    finish_ops_.set_core_cq_tag(&finish_tag_);
@ -956,7 +956,7 @@ class ClientCallbackWriterFactory {
 class ClientCallbackUnaryImpl final : public experimental::ClientCallbackUnary {
 public:
  // always allocated against a call arena, no memory free required
-  static void operator delete(void* ptr, std::size_t size) {
+  static void operator delete(void* /*ptr*/, std::size_t size) {
    assert(size == sizeof(ClientCallbackUnaryImpl));
  }

@ -985,7 +985,7 @@ class ClientCallbackUnaryImpl final : public experimental::ClientCallbackUnary {
    start_ops_.set_core_cq_tag(&start_tag_);
    call_.PerformOps(&start_ops_);

-    finish_tag_.Set(call_.call(), [this](bool ok) { MaybeFinish(); },
+    finish_tag_.Set(call_.call(), [this](bool /*ok*/) { MaybeFinish(); },
                    &finish_ops_);
    finish_ops_.ClientRecvStatus(context_, &finish_status_);
    finish_ops_.set_core_cq_tag(&finish_tag_);
--- a/include/grpcpp/impl/codegen/interceptor_common.h
+++ b/include/grpcpp/impl/codegen/interceptor_common.h
@ -465,7 +465,7 @@ class CancelInterceptorBatchMethods
    return nullptr;
  }

-  void ModifySendMessage(const void* message) override {
+  void ModifySendMessage(const void* /*message*/) override {
    GPR_CODEGEN_ASSERT(
        false &&
        "It is illegal to call ModifySendMessage on a method which "
@ -486,7 +486,7 @@ class CancelInterceptorBatchMethods
    return Status();
  }

-  void ModifySendStatus(const Status& status) override {
+  void ModifySendStatus(const Status& /*status*/) override {
    GPR_CODEGEN_ASSERT(false &&
                       "It is illegal to call ModifySendStatus on a method "
                       "which has a Cancel notification");
--- a/include/grpcpp/impl/codegen/method_handler_impl.h
+++ b/include/grpcpp/impl/codegen/method_handler_impl.h
@ -88,7 +88,7 @@ class RpcMethodHandler : public MethodHandler {
  }

  void* Deserialize(grpc_call* call, grpc_byte_buffer* req, Status* status,
-                    void** handler_data) final {
+                    void** /*handler_data*/) final {
    ByteBuffer buf;
    buf.set_buffer(req);
    auto* request = new (g_core_codegen_interface->grpc_call_arena_alloc(
@ -193,7 +193,7 @@ class ServerStreamingHandler : public MethodHandler {
  }

  void* Deserialize(grpc_call* call, grpc_byte_buffer* req, Status* status,
-                    void** handler_data) final {
+                    void** /*handler_data*/) final {
    ByteBuffer buf;
    buf.set_buffer(req);
    auto* request = new (g_core_codegen_interface->grpc_call_arena_alloc(
@ -328,8 +328,8 @@ class ErrorMethodHandler : public MethodHandler {
    param.call->cq()->Pluck(&ops);
  }

-  void* Deserialize(grpc_call* call, grpc_byte_buffer* req, Status* status,
-                    void** handler_data) final {
+  void* Deserialize(grpc_call* /*call*/, grpc_byte_buffer* req,
+                    Status* /*status*/, void** /*handler_data*/) final {
    // We have to destroy any request payload
    if (req != nullptr) {
      g_core_codegen_interface->grpc_byte_buffer_destroy(req);
--- a/include/grpcpp/impl/codegen/rpc_service_method.h
+++ b/include/grpcpp/impl/codegen/rpc_service_method.h
@ -76,8 +76,8 @@ class MethodHandler {
     a HandlerParameter and passed to RunHandler. It is illegal to access the
     pointer after calling RunHandler. Ownership of the deserialized request is
     retained by the handler. Returns nullptr if deserialization failed. */
-  virtual void* Deserialize(grpc_call* call, grpc_byte_buffer* req,
-                            Status* status, void** handler_data) {
+  virtual void* Deserialize(grpc_call* /*call*/, grpc_byte_buffer* req,
+                            Status* /*status*/, void** /*handler_data*/) {
    GPR_CODEGEN_ASSERT(req == nullptr);
    return nullptr;
  }
--- a/include/grpcpp/impl/codegen/server_callback_impl.h
+++ b/include/grpcpp/impl/codegen/server_callback_impl.h
@ -314,7 +314,7 @@ class ServerBidiReactor : public internal::ServerReactor {
  /// is a result of the client calling StartCall().
  ///
  /// \param[in] context The context object now associated with this RPC
-  virtual void OnStarted(::grpc_impl::ServerContext* context) {}
+  virtual void OnStarted(::grpc_impl::ServerContext* /*context*/) {}

  /// Notifies the application that an explicit StartSendInitialMetadata
  /// operation completed. Not used when the sending of initial metadata
@ -322,20 +322,20 @@ class ServerBidiReactor : public internal::ServerReactor {
  ///
  /// \param[in] ok Was it successful? If false, no further write-side operation
  ///               will succeed.
-  virtual void OnSendInitialMetadataDone(bool ok) {}
+  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}

  /// Notifies the application that a StartRead operation completed.
  ///
  /// \param[in] ok Was it successful? If false, no further read-side operation
  ///               will succeed.
-  virtual void OnReadDone(bool ok) {}
+  virtual void OnReadDone(bool /*ok*/) {}

  /// Notifies the application that a StartWrite (or StartWriteLast) operation
  /// completed.
  ///
  /// \param[in] ok Was it successful? If false, no further write-side operation
  ///               will succeed.
-  virtual void OnWriteDone(bool ok) {}
+  virtual void OnWriteDone(bool /*ok*/) {}

  /// Notifies the application that all operations associated with this RPC
  /// have completed. This is an override (from the internal base class) but not
@ -376,11 +376,12 @@ class ServerReadReactor : public internal::ServerReactor {
  ///
  /// \param[in] context The context object now associated with this RPC
  /// \param[in] resp The response object to be used by this RPC
-  virtual void OnStarted(::grpc_impl::ServerContext* context, Response* resp) {}
+  virtual void OnStarted(::grpc_impl::ServerContext* /*context*/,
+                         Response* /*resp*/) {}

  /// The following notifications are exactly like ServerBidiReactor.
-  virtual void OnSendInitialMetadataDone(bool ok) {}
-  virtual void OnReadDone(bool ok) {}
+  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}
+  virtual void OnReadDone(bool /*ok*/) {}
  void OnDone() override {}
  void OnCancel() override {}

@ -423,12 +424,12 @@ class ServerWriteReactor : public internal::ServerReactor {
  ///
  /// \param[in] context The context object now associated with this RPC
  /// \param[in] req The request object sent by the client
-  virtual void OnStarted(::grpc_impl::ServerContext* context,
-                         const Request* req) {}
+  virtual void OnStarted(::grpc_impl::ServerContext* /*context*/,
+                         const Request* /*req*/) {}

  /// The following notifications are exactly like ServerBidiReactor.
-  virtual void OnSendInitialMetadataDone(bool ok) {}
-  virtual void OnWriteDone(bool ok) {}
+  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}
+  virtual void OnWriteDone(bool /*ok*/) {}
  void OnDone() override {}
  void OnCancel() override {}

@ -849,7 +850,7 @@ class CallbackServerStreamingHandler : public grpc::internal::MethodHandler {
  }

  void* Deserialize(grpc_call* call, grpc_byte_buffer* req,
-                    ::grpc::Status* status, void** handler_data) final {
+                    ::grpc::Status* status, void** /*handler_data*/) final {
    ::grpc::ByteBuffer buf;
    buf.set_buffer(req);
    auto* request =
--- a/include/grpcpp/impl/codegen/server_interface.h
+++ b/include/grpcpp/impl/codegen/server_interface.h
@ -130,7 +130,7 @@ class ServerInterface : public internal::CallHook {
    virtual ~experimental_registration_interface() {}
    /// May not be abstract since this is a post-1.0 API addition
    virtual void RegisterCallbackGenericService(
-        experimental::CallbackGenericService* service) {}
+        experimental::CallbackGenericService* /*service*/) {}
  };

  /// NOTE: The function experimental_registration() is not stable public API.
--- a/include/grpcpp/impl/codegen/time.h
+++ b/include/grpcpp/impl/codegen/time.h
@ -39,7 +39,7 @@ namespace grpc {
 template <typename T>
 class TimePoint {
 public:
-  TimePoint(const T& time) { you_need_a_specialization_of_TimePoint(); }
+  TimePoint(const T& /*time*/) { you_need_a_specialization_of_TimePoint(); }
  gpr_timespec raw_time() {
    gpr_timespec t;
    return t;
--- a/include/grpcpp/impl/server_builder_plugin.h
+++ b/include/grpcpp/impl/server_builder_plugin.h
@ -42,7 +42,7 @@ class ServerBuilderPlugin {
  /// UpdateServerBuilder will be called at an early stage in
  /// ServerBuilder::BuildAndStart(), right after the ServerBuilderOptions have
  /// done their updates.
-  virtual void UpdateServerBuilder(grpc_impl::ServerBuilder* builder) {}
+  virtual void UpdateServerBuilder(grpc_impl::ServerBuilder* /*builder*/) {}

  /// InitServer will be called in ServerBuilder::BuildAndStart(), after the
  /// Server instance is created.
@ -57,7 +57,7 @@ class ServerBuilderPlugin {

  /// UpdateChannelArguments will be called in ServerBuilder::BuildAndStart(),
  /// before the Server instance is created.
-  virtual void UpdateChannelArguments(ChannelArguments* args) {}
+  virtual void UpdateChannelArguments(ChannelArguments* /*args*/) {}

  virtual bool has_sync_methods() const { return false; }
  virtual bool has_async_methods() const { return false; }
--- a/include/grpcpp/security/credentials_impl.h
+++ b/include/grpcpp/security/credentials_impl.h
@ -95,10 +95,10 @@ class ChannelCredentials : private grpc::GrpcLibraryCodegen {
  // This function should have been a pure virtual function, but it is
  // implemented as a virtual function so that it does not break API.
  virtual std::shared_ptr<Channel> CreateChannelWithInterceptors(
-      const grpc::string& target, const ChannelArguments& args,
+      const grpc::string& /*target*/, const ChannelArguments& /*args*/,
      std::vector<std::unique_ptr<
          grpc::experimental::ClientInterceptorFactoryInterface>>
-          interceptor_creators) {
+      /*interceptor_creators*/) {
    return nullptr;
  }
 };
--- a/include/grpcpp/server_impl.h
+++ b/include/grpcpp/server_impl.h
@ -81,16 +81,16 @@ class Server : public grpc::ServerInterface, private grpc::GrpcLibraryCodegen {
   public:
    virtual ~GlobalCallbacks() {}
    /// Called before server is created.
-    virtual void UpdateArguments(ChannelArguments* args) {}
+    virtual void UpdateArguments(ChannelArguments* /*args*/) {}
    /// Called before application callback for each synchronous server request
    virtual void PreSynchronousRequest(grpc_impl::ServerContext* context) = 0;
    /// Called after application callback for each synchronous server request
    virtual void PostSynchronousRequest(grpc_impl::ServerContext* context) = 0;
    /// Called before server is started.
-    virtual void PreServerStart(Server* server) {}
+    virtual void PreServerStart(Server* /*server*/) {}
    /// Called after a server port is added.
-    virtual void AddPort(Server* server, const grpc::string& addr,
-                         grpc::ServerCredentials* creds, int port) {}
+    virtual void AddPort(Server* /*server*/, const grpc::string& /*addr*/,
+                         grpc::ServerCredentials* /*creds*/, int /*port*/) {}
  };
  /// Set the global callback object. Can only be called once per application.
  /// Does not take ownership of callbacks, and expects the pointed to object
--- a/include/grpcpp/support/channel_arguments_impl.h
+++ b/include/grpcpp/support/channel_arguments_impl.h
@ -132,7 +132,7 @@ class ChannelArguments {
  /// Default pointer argument operations.
  struct PointerVtableMembers {
    static void* Copy(void* in) { return in; }
-    static void Destroy(void* in) {}
+    static void Destroy(void* /*in*/) {}
    static int Compare(void* a, void* b) {
      if (a < b) return -1;
      if (a > b) return 1;
--- a/src/compiler/cpp_generator.cc
+++ b/src/compiler/cpp_generator.cc
@ -794,8 +794,8 @@ void PrintHeaderServerAsyncMethodsHelper(
        *vars,
        "// disable synchronous version of this method\n"
        "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, const $Request$* request, "
-        "$Response$* response) override {\n"
+        "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
+        "$Response$* /*response*/) override {\n"
        "  abort();\n"
        "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
        "}\n");
@ -815,9 +815,9 @@ void PrintHeaderServerAsyncMethodsHelper(
        *vars,
        "// disable synchronous version of this method\n"
        "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, "
-        "::grpc::ServerReader< $Request$>* reader, "
-        "$Response$* response) override {\n"
+        "::grpc::ServerContext* /*context*/, "
+        "::grpc::ServerReader< $Request$>* /*reader*/, "
+        "$Response$* /*response*/) override {\n"
        "  abort();\n"
        "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
        "}\n");
@ -837,8 +837,8 @@ void PrintHeaderServerAsyncMethodsHelper(
        *vars,
        "// disable synchronous version of this method\n"
        "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, const $Request$* request, "
-        "::grpc::ServerWriter< $Response$>* writer) override "
+        "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
+        "::grpc::ServerWriter< $Response$>* /*writer*/) override "
        "{\n"
        "  abort();\n"
        "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@ -860,8 +860,8 @@ void PrintHeaderServerAsyncMethodsHelper(
        *vars,
        "// disable synchronous version of this method\n"
        "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, "
-        "::grpc::ServerReaderWriter< $Response$, $Request$>* stream) "
+        "::grpc::ServerContext* /*context*/, "
+        "::grpc::ServerReaderWriter< $Response$, $Request$>* /*stream*/) "
        " override {\n"
        "  abort();\n"
        "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@ -896,7 +896,8 @@ void PrintHeaderServerMethodAsync(grpc_generator::Printer* printer,
                 "class WithAsyncMethod_$Method$ : public BaseClass {\n");
  printer->Print(
      " private:\n"
-      "  void BaseClassMustBeDerivedFromService(const Service *service) {}\n");
+      "  void BaseClassMustBeDerivedFromService(const Service* /*service*/) "
+      "{}\n");
  printer->Print(" public:\n");
  printer->Indent();
  printer->Print(*vars,
@ -923,16 +924,16 @@ void PrintHeaderServerCallbackMethodsHelper(
        *vars,
        "// disable synchronous version of this method\n"
        "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, const $Request$* request, "
-        "$Response$* response) override {\n"
+        "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
+        "$Response$* /*response*/) override {\n"
        "  abort();\n"
        "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
        "}\n");
    printer->Print(
        *vars,
        "virtual void $Method$("
-        "::grpc::ServerContext* context, const $RealRequest$* request, "
-        "$RealResponse$* response, "
+        "::grpc::ServerContext* /*context*/, const $RealRequest$* /*request*/, "
+        "$RealResponse$* /*response*/, "
        "::grpc::experimental::ServerCallbackRpcController* "
        "controller) { controller->Finish(::grpc::Status("
        "::grpc::StatusCode::UNIMPLEMENTED, \"\")); }\n");
@ -941,9 +942,9 @@ void PrintHeaderServerCallbackMethodsHelper(
        *vars,
        "// disable synchronous version of this method\n"
        "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, "
-        "::grpc::ServerReader< $Request$>* reader, "
-        "$Response$* response) override {\n"
+        "::grpc::ServerContext* /*context*/, "
+        "::grpc::ServerReader< $Request$>* /*reader*/, "
+        "$Response$* /*response*/) override {\n"
        "  abort();\n"
        "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
        "}\n");
@ -958,8 +959,8 @@ void PrintHeaderServerCallbackMethodsHelper(
        *vars,
        "// disable synchronous version of this method\n"
        "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, const $Request$* request, "
-        "::grpc::ServerWriter< $Response$>* writer) override "
+        "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
+        "::grpc::ServerWriter< $Response$>* /*writer*/) override "
        "{\n"
        "  abort();\n"
        "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@ -975,8 +976,8 @@ void PrintHeaderServerCallbackMethodsHelper(
        *vars,
        "// disable synchronous version of this method\n"
        "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, "
-        "::grpc::ServerReaderWriter< $Response$, $Request$>* stream) "
+        "::grpc::ServerContext* /*context*/, "
+        "::grpc::ServerReaderWriter< $Response$, $Request$>* /*stream*/) "
        " override {\n"
        "  abort();\n"
        "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@ -1006,7 +1007,8 @@ void PrintHeaderServerMethodCallback(
      "class ExperimentalWithCallbackMethod_$Method$ : public BaseClass {\n");
  printer->Print(
      " private:\n"
-      "  void BaseClassMustBeDerivedFromService(const Service *service) {}\n");
+      "  void BaseClassMustBeDerivedFromService(const Service* /*service*/) "
+      "{}\n");
  printer->Print(" public:\n");
  printer->Indent();
  printer->Print(*vars, "ExperimentalWithCallbackMethod_$Method$() {\n");
@ -1080,7 +1082,8 @@ void PrintHeaderServerMethodRawCallback(
                 "BaseClass {\n");
  printer->Print(
      " private:\n"
-      "  void BaseClassMustBeDerivedFromService(const Service *service) {}\n");
+      "  void BaseClassMustBeDerivedFromService(const Service* /*service*/) "
+      "{}\n");
  printer->Print(" public:\n");
  printer->Indent();
  printer->Print(*vars, "ExperimentalWithRawCallbackMethod_$Method$() {\n");
@ -1143,7 +1146,7 @@ void PrintHeaderServerMethodStreamedUnary(
                   "public BaseClass {\n");
    printer->Print(
        " private:\n"
-        "  void BaseClassMustBeDerivedFromService(const Service *service) "
+        "  void BaseClassMustBeDerivedFromService(const Service* /*service*/) "
        "{}\n");
    printer->Print(" public:\n");
    printer->Indent();
@ -1164,8 +1167,8 @@ void PrintHeaderServerMethodStreamedUnary(
        *vars,
        "// disable regular version of this method\n"
        "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, const $Request$* request, "
-        "$Response$* response) override {\n"
+        "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
+        "$Response$* /*response*/) override {\n"
        "  abort();\n"
        "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
        "}\n");
@ -1194,7 +1197,7 @@ void PrintHeaderServerMethodSplitStreaming(
                   "public BaseClass {\n");
    printer->Print(
        " private:\n"
-        "  void BaseClassMustBeDerivedFromService(const Service *service) "
+        "  void BaseClassMustBeDerivedFromService(const Service* /*service*/) "
        "{}\n");
    printer->Print(" public:\n");
    printer->Indent();
@ -1216,8 +1219,8 @@ void PrintHeaderServerMethodSplitStreaming(
        *vars,
        "// disable regular version of this method\n"
        "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, const $Request$* request, "
-        "::grpc::ServerWriter< $Response$>* writer) override "
+        "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
+        "::grpc::ServerWriter< $Response$>* /*writer*/) override "
        "{\n"
        "  abort();\n"
        "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@ -1245,7 +1248,8 @@ void PrintHeaderServerMethodGeneric(
                 "class WithGenericMethod_$Method$ : public BaseClass {\n");
  printer->Print(
      " private:\n"
-      "  void BaseClassMustBeDerivedFromService(const Service *service) {}\n");
+      "  void BaseClassMustBeDerivedFromService(const Service* /*service*/) "
+      "{}\n");
  printer->Print(" public:\n");
  printer->Indent();
  printer->Print(*vars,
@ -1261,8 +1265,8 @@ void PrintHeaderServerMethodGeneric(
        *vars,
        "// disable synchronous version of this method\n"
        "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, const $Request$* request, "
-        "$Response$* response) override {\n"
+        "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
+        "$Response$* /*response*/) override {\n"
        "  abort();\n"
        "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
        "}\n");
@ -1271,9 +1275,9 @@ void PrintHeaderServerMethodGeneric(
        *vars,
        "// disable synchronous version of this method\n"
        "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, "
-        "::grpc::ServerReader< $Request$>* reader, "
-        "$Response$* response) override {\n"
+        "::grpc::ServerContext* /*context*/, "
+        "::grpc::ServerReader< $Request$>* /*reader*/, "
+        "$Response$* /*response*/) override {\n"
        "  abort();\n"
        "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
        "}\n");
@ -1282,8 +1286,8 @@ void PrintHeaderServerMethodGeneric(
        *vars,
        "// disable synchronous version of this method\n"
        "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, const $Request$* request, "
-        "::grpc::ServerWriter< $Response$>* writer) override "
+        "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
+        "::grpc::ServerWriter< $Response$>* /*writer*/) override "
        "{\n"
        "  abort();\n"
        "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@ -1293,8 +1297,8 @@ void PrintHeaderServerMethodGeneric(
        *vars,
        "// disable synchronous version of this method\n"
        "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, "
-        "::grpc::ServerReaderWriter< $Response$, $Request$>* stream) "
+        "::grpc::ServerContext* /*context*/, "
+        "::grpc::ServerReaderWriter< $Response$, $Request$>* /*stream*/) "
        " override {\n"
        "  abort();\n"
        "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@ -1318,7 +1322,8 @@ void PrintHeaderServerMethodRaw(grpc_generator::Printer* printer,
  printer->Print(*vars, "class WithRawMethod_$Method$ : public BaseClass {\n");
  printer->Print(
      " private:\n"
-      "  void BaseClassMustBeDerivedFromService(const Service *service) {}\n");
+      "  void BaseClassMustBeDerivedFromService(const Service* /*service*/) "
+      "{}\n");
  printer->Print(" public:\n");
  printer->Indent();
  printer->Print(*vars,
--- a/test/cpp/codegen/compiler_test_golden
+++ b/test/cpp/codegen/compiler_test_golden
@ -252,7 +252,7 @@ class ServiceA final {
  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);
@ -261,7 +261,7 @@ class ServiceA final {
      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, "");
    }
@ -272,7 +272,7 @@ class ServiceA final {
  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);
@ -281,7 +281,7 @@ class ServiceA final {
      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, "");
    }
@ -292,7 +292,7 @@ class ServiceA final {
  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);
@ -301,7 +301,7 @@ class ServiceA final {
      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, "");
    }
@ -312,7 +312,7 @@ class ServiceA final {
  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);
@ -321,7 +321,7 @@ class ServiceA final {
      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, "");
    }
@ -333,7 +333,7 @@ class ServiceA final {
  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,
@ -355,16 +355,16 @@ class ServiceA final {
      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() {
      ::grpc::Service::experimental().MarkMethodCallback(1,
@ -375,7 +375,7 @@ class ServiceA final {
      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, "");
    }
@ -386,7 +386,7 @@ 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() {
      ::grpc::Service::experimental().MarkMethodCallback(2,
@ -397,7 +397,7 @@ class ServiceA final {
      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, "");
    }
@ -408,7 +408,7 @@ 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() {
      ::grpc::Service::experimental().MarkMethodCallback(3,
@ -419,7 +419,7 @@ class ServiceA final {
      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, "");
    }
@ -431,7 +431,7 @@ class ServiceA final {
  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);
@ -440,7 +440,7 @@ class ServiceA final {
      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, "");
    }
@ -448,7 +448,7 @@ 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);
@ -457,7 +457,7 @@ class ServiceA final {
      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, "");
    }
@ -465,7 +465,7 @@ 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);
@ -474,7 +474,7 @@ class ServiceA final {
      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, "");
    }
@ -482,7 +482,7 @@ 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);
@ -491,7 +491,7 @@ class ServiceA final {
      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, "");
    }
@ -499,7 +499,7 @@ 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);
@ -508,7 +508,7 @@ class ServiceA final {
      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, "");
    }
@ -519,7 +519,7 @@ class ServiceA final {
  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);
@ -528,7 +528,7 @@ class ServiceA final {
      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, "");
    }
@ -539,7 +539,7 @@ class ServiceA final {
  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);
@ -548,7 +548,7 @@ class ServiceA final {
      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, "");
    }
@ -559,7 +559,7 @@ class ServiceA final {
  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);
@ -568,7 +568,7 @@ class ServiceA final {
      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, "");
    }
@ -579,7 +579,7 @@ class ServiceA final {
  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,
@ -595,16 +595,16 @@ class ServiceA final {
      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() {
      ::grpc::Service::experimental().MarkMethodRawCallback(1,
@ -615,7 +615,7 @@ class ServiceA final {
      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, "");
    }
@ -626,7 +626,7 @@ 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() {
      ::grpc::Service::experimental().MarkMethodRawCallback(2,
@ -637,7 +637,7 @@ class ServiceA final {
      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, "");
    }
@ -648,7 +648,7 @@ 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() {
      ::grpc::Service::experimental().MarkMethodRawCallback(3,
@ -659,7 +659,7 @@ class ServiceA final {
      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, "");
    }
@ -670,7 +670,7 @@ 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,
@ -680,7 +680,7 @@ class ServiceA final {
      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, "");
    }
@ -691,7 +691,7 @@ class ServiceA final {
  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,
@ -701,7 +701,7 @@ class ServiceA final {
      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, "");
    }
@ -790,7 +790,7 @@ class ServiceB final {
  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);
@ -799,7 +799,7 @@ class ServiceB final {
      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, "");
    }
@ -811,7 +811,7 @@ class ServiceB final {
  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,
@ -833,17 +833,17 @@ class ServiceB final {
      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;
  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);
@ -852,7 +852,7 @@ class ServiceB final {
      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, "");
    }
@ -860,7 +860,7 @@ 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);
@ -869,7 +869,7 @@ class ServiceB final {
      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, "");
    }
@ -880,7 +880,7 @@ class ServiceB final {
  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,
@ -896,16 +896,16 @@ class ServiceB final {
      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,
@ -915,7 +915,7 @@ class ServiceB final {
      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, "");
    }