Merge pull request #24448 An error occurred from veblush/clang-format-8

Upgrade clang-format 8

include/grpcpp/impl/codegen/client_callback.h

@@ -537,7 +537,8 @@ class ClientCallbackReaderWriterImpl
   }
   void WritesDone() override {
     writes_done_ops_.ClientSendClose();
-    writes_done_tag_.Set(call_.call(),
+    writes_done_tag_.Set(
+        call_.call(),
         [this](bool ok) {
           reactor_->OnWritesDoneDone(ok);
           MaybeFinish(/*from_reaction=*/true);
@@ -579,7 +580,8 @@ class ClientCallbackReaderWriterImpl
     this->BindReactor(reactor);
 
     // Set up the unchanging parts of the start, read, and write tags and ops.
-    start_tag_.Set(call_.call(),
+    start_tag_.Set(
+        call_.call(),
         [this](bool ok) {
           reactor_->OnReadInitialMetadataDone(ok);
           MaybeFinish(/*from_reaction=*/true);
@@ -588,7 +590,8 @@ class ClientCallbackReaderWriterImpl
     start_ops_.RecvInitialMetadata(context_);
     start_ops_.set_core_cq_tag(&start_tag_);
 
-    write_tag_.Set(call_.call(),
+    write_tag_.Set(
+        call_.call(),
         [this](bool ok) {
           reactor_->OnWriteDone(ok);
           MaybeFinish(/*from_reaction=*/true);
@@ -596,7 +599,8 @@ class ClientCallbackReaderWriterImpl
         &write_ops_, /*can_inline=*/false);
     write_ops_.set_core_cq_tag(&write_tag_);
 
-    read_tag_.Set(call_.call(),
+    read_tag_.Set(
+        call_.call(),
         [this](bool ok) {
           reactor_->OnReadDone(ok);
           MaybeFinish(/*from_reaction=*/true);
@@ -719,7 +723,8 @@ class ClientCallbackReaderImpl : public ClientCallbackReader<Response> {
     // 2. Any backlog
     // 3. Recv trailing metadata
 
-    start_tag_.Set(call_.call(),
+    start_tag_.Set(
+        call_.call(),
         [this](bool ok) {
           reactor_->OnReadInitialMetadataDone(ok);
           MaybeFinish(/*from_reaction=*/true);
@@ -732,7 +737,8 @@ class ClientCallbackReaderImpl : public ClientCallbackReader<Response> {
     call_.PerformOps(&start_ops_);
 
     // Also set up the read tag so it doesn't have to be set up each time
-    read_tag_.Set(call_.call(),
+    read_tag_.Set(
+        call_.call(),
         [this](bool ok) {
           reactor_->OnReadDone(ok);
           MaybeFinish(/*from_reaction=*/true);
@@ -928,7 +934,8 @@ class ClientCallbackWriterImpl : public ClientCallbackWriter<Request> {
 
   void WritesDone() override {
     writes_done_ops_.ClientSendClose();
-    writes_done_tag_.Set(call_.call(),
+    writes_done_tag_.Set(
+        call_.call(),
         [this](bool ok) {
           reactor_->OnWritesDoneDone(ok);
           MaybeFinish(/*from_reaction=*/true);
@@ -973,7 +980,8 @@ class ClientCallbackWriterImpl : public ClientCallbackWriter<Request> {
     this->BindReactor(reactor);
 
     // Set up the unchanging parts of the start and write tags and ops.
-    start_tag_.Set(call_.call(),
+    start_tag_.Set(
+        call_.call(),
         [this](bool ok) {
           reactor_->OnReadInitialMetadataDone(ok);
           MaybeFinish(/*from_reaction=*/true);
@@ -982,7 +990,8 @@ class ClientCallbackWriterImpl : public ClientCallbackWriter<Request> {
     start_ops_.RecvInitialMetadata(context_);
     start_ops_.set_core_cq_tag(&start_tag_);
 
-    write_tag_.Set(call_.call(),
+    write_tag_.Set(
+        call_.call(),
         [this](bool ok) {
           reactor_->OnWriteDone(ok);
           MaybeFinish(/*from_reaction=*/true);
@@ -1097,7 +1106,8 @@ class ClientCallbackUnaryImpl final : public ClientCallbackUnary {
     // 1. Send initial metadata + write + writes done + recv initial metadata
     // 2. Read message, recv trailing metadata
 
-    start_tag_.Set(call_.call(),
+    start_tag_.Set(
+        call_.call(),
         [this](bool ok) {
           reactor_->OnReadInitialMetadataDone(ok);
           MaybeFinish();
@@ -1109,8 +1119,8 @@ class ClientCallbackUnaryImpl final : public 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(
-                    &finish_ops_,
+        call_.call(), [this](bool /*ok*/) { MaybeFinish(); }, &finish_ops_,
         /*can_inline=*/false);
     finish_ops_.ClientRecvStatus(context_, &finish_status_);
     finish_ops_.set_core_cq_tag(&finish_tag_);

include/grpcpp/impl/codegen/server_callback_handlers.h

@@ -157,7 +157,8 @@ class CallbackUnaryHandler : public ::grpc::internal::MethodHandler {
       // (OnSendInitialMetadataDone). Thus it must be dispatched to an executor
       // thread. However, any OnDone needed after that can be inlined because it
       // is already running on an executor thread.
-      meta_tag_.Set(call_.call(),
+      meta_tag_.Set(
+          call_.call(),
           [this](bool ok) {
             ServerUnaryReactor* reactor =
                 reactor_.load(std::memory_order_relaxed);
@@ -305,7 +306,8 @@ class CallbackClientStreamingHandler : public ::grpc::internal::MethodHandler {
       // A finish tag with only MaybeDone can have its callback inlined
       // regardless even if OnDone is not inlineable because this callback just
       // checks a ref and then decides whether or not to dispatch OnDone.
-      finish_tag_.Set(call_.call(),
+      finish_tag_.Set(
+          call_.call(),
           [this](bool) {
             // Inlineable OnDone can be false here because there is
             // no read reactor that has an inlineable OnDone; this
@@ -338,7 +340,8 @@ class CallbackClientStreamingHandler : public ::grpc::internal::MethodHandler {
       // The callback for this function should not be inlined because it invokes
       // a user-controlled reaction, but any resulting OnDone can be inlined in
       // the executor to which this callback is dispatched.
-      meta_tag_.Set(call_.call(),
+      meta_tag_.Set(
+          call_.call(),
           [this](bool ok) {
             ServerReadReactor<RequestType>* reactor =
                 reactor_.load(std::memory_order_relaxed);
@@ -375,7 +378,8 @@ class CallbackClientStreamingHandler : public ::grpc::internal::MethodHandler {
       // The callback for this function should not be inlined because it invokes
       // a user-controlled reaction, but any resulting OnDone can be inlined in
       // the executor to which this callback is dispatched.
-      read_tag_.Set(call_.call(),
+      read_tag_.Set(
+          call_.call(),
           [this, reactor](bool ok) {
             reactor->OnReadDone(ok);
             this->MaybeDone(/*inlineable_ondone=*/true);
@@ -505,7 +509,8 @@ class CallbackServerStreamingHandler : public ::grpc::internal::MethodHandler {
       // A finish tag with only MaybeDone can have its callback inlined
       // regardless even if OnDone is not inlineable because this callback just
       // checks a ref and then decides whether or not to dispatch OnDone.
-      finish_tag_.Set(call_.call(),
+      finish_tag_.Set(
+          call_.call(),
           [this](bool) {
             // Inlineable OnDone can be false here because there is
             // no write reactor that has an inlineable OnDone; this
@@ -533,7 +538,8 @@ class CallbackServerStreamingHandler : public ::grpc::internal::MethodHandler {
       // The callback for this function should not be inlined because it invokes
       // a user-controlled reaction, but any resulting OnDone can be inlined in
       // the executor to which this callback is dispatched.
-      meta_tag_.Set(call_.call(),
+      meta_tag_.Set(
+          call_.call(),
           [this](bool ok) {
             ServerWriteReactor<ResponseType>* reactor =
                 reactor_.load(std::memory_order_relaxed);
@@ -595,7 +601,8 @@ class CallbackServerStreamingHandler : public ::grpc::internal::MethodHandler {
       // The callback for this function should not be inlined because it invokes
       // a user-controlled reaction, but any resulting OnDone can be inlined in
       // the executor to which this callback is dispatched.
-      write_tag_.Set(call_.call(),
+      write_tag_.Set(
+          call_.call(),
           [this, reactor](bool ok) {
             reactor->OnWriteDone(ok);
             this->MaybeDone(/*inlineable_ondone=*/true);
@@ -707,7 +714,8 @@ class CallbackBidiHandler : public ::grpc::internal::MethodHandler {
       // A finish tag with only MaybeDone can have its callback inlined
       // regardless even if OnDone is not inlineable because this callback just
       // checks a ref and then decides whether or not to dispatch OnDone.
-      finish_tag_.Set(call_.call(),
+      finish_tag_.Set(
+          call_.call(),
           [this](bool) {
             // Inlineable OnDone can be false here because there is
             // no bidi reactor that has an inlineable OnDone; this
@@ -735,7 +743,8 @@ class CallbackBidiHandler : public ::grpc::internal::MethodHandler {
       // The callback for this function should not be inlined because it invokes
       // a user-controlled reaction, but any resulting OnDone can be inlined in
       // the executor to which this callback is dispatched.
-      meta_tag_.Set(call_.call(),
+      meta_tag_.Set(
+          call_.call(),
           [this](bool ok) {
             ServerBidiReactor<RequestType, ResponseType>* reactor =
                 reactor_.load(std::memory_order_relaxed);
@@ -798,14 +807,16 @@ class CallbackBidiHandler : public ::grpc::internal::MethodHandler {
       // The callbacks for these functions should not be inlined because they
       // invoke user-controlled reactions, but any resulting OnDones can be
       // inlined in the executor to which a callback is dispatched.
-      write_tag_.Set(call_.call(),
+      write_tag_.Set(
+          call_.call(),
           [this, reactor](bool ok) {
             reactor->OnWriteDone(ok);
             this->MaybeDone(/*inlineable_ondone=*/true);
           },
           &write_ops_, /*can_inline=*/false);
       write_ops_.set_core_cq_tag(&write_tag_);
-      read_tag_.Set(call_.call(),
+      read_tag_.Set(
+          call_.call(),
           [this, reactor](bool ok) {
             reactor->OnReadDone(ok);
             this->MaybeDone(/*inlineable_ondone=*/true);

src/core/ext/filters/client_channel/subchannel.cc

@@ -391,9 +391,9 @@ class Subchannel::AsyncWatcherNotifierLocked {
     }
     watcher_->PushConnectivityStateChange(
         {state, status, std::move(connected_subchannel)});
-    ExecCtx::Run(
+    ExecCtx::Run(DEBUG_LOCATION,
-        DEBUG_LOCATION,
+                 GRPC_CLOSURE_INIT(
-        GRPC_CLOSURE_INIT(&closure_,
+                     &closure_,
                      [](void* arg, grpc_error* /*error*/) {
                        auto* self =
                            static_cast<AsyncWatcherNotifierLocked*>(arg);

src/core/lib/gprpp/thd_posix.cc

@@ -105,8 +105,8 @@ class ThreadInternalsPosix : public internal::ThreadInternalsInterface {
       GPR_ASSERT(pthread_attr_setstacksize(&attr, stack_size) == 0);
     }
 
-    *success =
+    *success = (pthread_create(
-        (pthread_create(&pthread_id_, &attr,
+                    &pthread_id_, &attr,
                     [](void* v) -> void* {
                       thd_arg arg = *static_cast<thd_arg*>(v);
                       free(v);

src/core/lib/iomgr/executor/threadpool.h

@@ -65,8 +65,8 @@ class ThreadPoolWorker {
   ThreadPoolWorker(const char* thd_name, MPMCQueueInterface* queue,
                    Thread::Options& options, int index)
       : queue_(queue), thd_name_(thd_name), index_(index) {
-    thd_ = Thread(thd_name,
+    thd_ = Thread(
-                  [](void* th) { static_cast<ThreadPoolWorker*>(th)->Run(); },
+        thd_name, [](void* th) { static_cast<ThreadPoolWorker*>(th)->Run(); },
         this, nullptr, options);
   }
 

src/core/tsi/alts/handshaker/alts_tsi_handshaker.cc

@@ -394,9 +394,10 @@ static void on_handshaker_service_resp_recv_dedicated(void* arg,
                                                       grpc_error* /*error*/) {
   alts_shared_resource_dedicated* resource =
       grpc_alts_get_shared_resource_dedicated();
-  grpc_cq_end_op(resource->cq, arg, GRPC_ERROR_NONE,
+  grpc_cq_end_op(
-                 [](void* /*done_arg*/, grpc_cq_completion* /*storage*/) {},
+      resource->cq, arg, GRPC_ERROR_NONE,
-                 nullptr, &resource->storage);
+      [](void* /*done_arg*/, grpc_cq_completion* /*storage*/) {}, nullptr,
+      &resource->storage);
 }
 
 /* Returns TSI_OK if and only if no error is encountered. */

src/cpp/client/client_callback.cc

@@ -34,10 +34,10 @@ void ClientReactor::InternalScheduleOnDone(grpc::Status s) {
     const grpc::Status status;
     ClosureWithArg(ClientReactor* reactor_arg, grpc::Status s)
         : reactor(reactor_arg), status(std::move(s)) {
-      GRPC_CLOSURE_INIT(&closure,
+      GRPC_CLOSURE_INIT(
+          &closure,
           [](void* void_arg, grpc_error*) {
-                          ClosureWithArg* arg =
+            ClosureWithArg* arg = static_cast<ClosureWithArg*>(void_arg);
-                              static_cast<ClosureWithArg*>(void_arg);
             arg->reactor->OnDone(arg->status);
             delete arg;
           },

src/cpp/common/alarm.cc

@@ -80,13 +80,13 @@ class AlarmImpl : public ::grpc::internal::CompletionQueueTag {
     // Don't use any CQ at all. Instead just use the timer to fire the function
     callback_ = std::move(f);
     Ref();
-    GRPC_CLOSURE_INIT(&on_alarm_,
+    GRPC_CLOSURE_INIT(
+        &on_alarm_,
         [](void* arg, grpc_error* error) {
           grpc_core::Executor::Run(
               GRPC_CLOSURE_CREATE(
                   [](void* arg, grpc_error* error) {
-                                  AlarmImpl* alarm =
+                    AlarmImpl* alarm = static_cast<AlarmImpl*>(arg);
-                                      static_cast<AlarmImpl*>(arg);
                     alarm->callback_(error == GRPC_ERROR_NONE);
                     alarm->Unref();
                   },

src/cpp/server/dynamic_thread_pool.cc

@@ -27,7 +27,8 @@ namespace grpc {
 
 DynamicThreadPool::DynamicThread::DynamicThread(DynamicThreadPool* pool)
     : pool_(pool),
-      thd_("grpcpp_dynamic_pool",
+      thd_(
+          "grpcpp_dynamic_pool",
           [](void* th) {
             static_cast<DynamicThreadPool::DynamicThread*>(th)->ThreadFunc();
           },

src/cpp/server/server_callback.cc

@@ -35,10 +35,10 @@ void ServerCallbackCall::ScheduleOnDone(bool inline_ondone) {
       grpc_closure closure;
       ServerCallbackCall* call;
       explicit ClosureWithArg(ServerCallbackCall* call_arg) : call(call_arg) {
-        GRPC_CLOSURE_INIT(&closure,
+        GRPC_CLOSURE_INIT(
+            &closure,
             [](void* void_arg, grpc_error*) {
-                            ClosureWithArg* arg =
+              ClosureWithArg* arg = static_cast<ClosureWithArg*>(void_arg);
-                                static_cast<ClosureWithArg*>(void_arg);
               arg->call->CallOnDone();
               delete arg;
             },
@@ -64,10 +64,10 @@ void ServerCallbackCall::CallOnCancel(ServerReactor* reactor) {
       ServerReactor* reactor;
       ClosureWithArg(ServerCallbackCall* call_arg, ServerReactor* reactor_arg)
           : call(call_arg), reactor(reactor_arg) {
-        GRPC_CLOSURE_INIT(&closure,
+        GRPC_CLOSURE_INIT(
+            &closure,
             [](void* void_arg, grpc_error*) {
-                            ClosureWithArg* arg =
+              ClosureWithArg* arg = static_cast<ClosureWithArg*>(void_arg);
-                                static_cast<ClosureWithArg*>(void_arg);
               arg->reactor->OnCancel();
               arg->call->MaybeDone();
               delete arg;

templates/tools/dockerfile/grpc_clang_format/Dockerfile.template

@@ -16,7 +16,13 @@
 
   FROM debian:10
 
-  RUN apt-get update && apt-get install -y clang-format
+  # Add buster-backports for more recent clang packages
+  RUN echo "deb http://deb.debian.org/debian buster-backports main" | tee /etc/apt/sources.list.d/buster-backports.list
+
+  # Install clang-format
+  RUN apt-get update && apt-get install -y clang-format-8
+  ENV CLANG_FORMAT=clang-format-8
+
   ADD clang_format_all_the_things.sh /
   
   # When running locally, we'll be impersonating the current user, so we need

templates/tools/dockerfile/test/sanity/Dockerfile.template

@@ -37,8 +37,8 @@
   RUN echo "deb http://deb.debian.org/debian buster-backports main" | tee /etc/apt/sources.list.d/buster-backports.list
 
   # Install clang, clang-format, and clang-tidy
-  RUN apt-get update && apt-get install -y clang clang-format-7 clang-tidy-8 jq
+  RUN apt-get update && apt-get install -y clang clang-format-8 clang-tidy-8 jq
-  ENV CLANG_FORMAT=clang-format-7
+  ENV CLANG_FORMAT=clang-format-8
   ENV CLANG_TIDY=clang-tidy-8
 
 

test/cpp/microbenchmarks/bm_timer.cc

@@ -46,9 +46,9 @@ static void BM_InitCancelTimer(benchmark::State& state) {
   int i = 0;
   for (auto _ : state) {
     TimerClosure* timer_closure = &timer_closures[i++ % kTimerCount];
-    GRPC_CLOSURE_INIT(&timer_closure->closure,
+    GRPC_CLOSURE_INIT(
-                      [](void* /*args*/, grpc_error* /*err*/) {}, nullptr,
+        &timer_closure->closure, [](void* /*args*/, grpc_error* /*err*/) {},
-                      grpc_schedule_on_exec_ctx);
+        nullptr, grpc_schedule_on_exec_ctx);
     grpc_timer_init(&timer_closure->timer, GRPC_MILLIS_INF_FUTURE,
                     &timer_closure->closure);
     grpc_timer_cancel(&timer_closure->timer);
@@ -75,9 +75,9 @@ static void BM_TimerBatch(benchmark::State& state) {
   for (auto _ : state) {
     for (grpc_millis deadline = start; deadline != end; deadline += increment) {
       TimerClosure* timer_closure = &timer_closures[deadline % kTimerCount];
-      GRPC_CLOSURE_INIT(&timer_closure->closure,
+      GRPC_CLOSURE_INIT(
-                        [](void* /*args*/, grpc_error* /*err*/) {}, nullptr,
+          &timer_closure->closure, [](void* /*args*/, grpc_error* /*err*/) {},
-                        grpc_schedule_on_exec_ctx);
+          nullptr, grpc_schedule_on_exec_ctx);
 
       grpc_timer_init(&timer_closure->timer, deadline, &timer_closure->closure);
     }

test/cpp/util/slice_test.cc

@@ -94,7 +94,8 @@ TEST_F(SliceTest, SliceNewWithUserData) {
   auto* t = new stest;
   t->x = new char[strlen(kContent) + 1];
   strcpy(t->x, kContent);
-  Slice spp(t->x, strlen(t->x),
+  Slice spp(
+      t->x, strlen(t->x),
       [](void* p) {
         auto* t = static_cast<stest*>(p);
         delete[] t->x;

tools/dockerfile/grpc_clang_format/Dockerfile

@@ -14,7 +14,13 @@
 
 FROM debian:10
 
-RUN apt-get update && apt-get install -y clang-format
+# Add buster-backports for more recent clang packages
+RUN echo "deb http://deb.debian.org/debian buster-backports main" | tee /etc/apt/sources.list.d/buster-backports.list
+
+# Install clang-format
+RUN apt-get update && apt-get install -y clang-format-8
+ENV CLANG_FORMAT=clang-format-8
+
 ADD clang_format_all_the_things.sh /
 
 # When running locally, we'll be impersonating the current user, so we need

tools/dockerfile/test/sanity/Dockerfile

@@ -85,8 +85,8 @@ RUN python3 -m pip install simplejson mako virtualenv==16.7.9 lxml
 RUN echo "deb http://deb.debian.org/debian buster-backports main" | tee /etc/apt/sources.list.d/buster-backports.list
 
 # Install clang, clang-format, and clang-tidy
-RUN apt-get update && apt-get install -y clang clang-format-7 clang-tidy-8 jq
+RUN apt-get update && apt-get install -y clang clang-format-8 clang-tidy-8 jq
-ENV CLANG_FORMAT=clang-format-7
+ENV CLANG_FORMAT=clang-format-8
 ENV CLANG_TIDY=clang-tidy-8