Add braces to C++ single-line loops and conditionals (NFC) (#2973)

This makes code easier to read and more consistent between C++ and Java.
Also update clang-format settings to always add a line break (even if no braces are used).

wpiutil/src/main/native/cpp/uv/Async.cpp

@@ -10,10 +10,11 @@ namespace wpi {
 namespace uv {
 
 Async<>::~Async() noexcept {
-  if (auto loop = m_loop.lock())
+  if (auto loop = m_loop.lock()) {
     Close();
-  else
+  } else {
     ForceClosed();
+  }
 }
 
 std::shared_ptr<Async<>> Async<>::Create(const std::shared_ptr<Loop>& loop) {

wpiutil/src/main/native/cpp/uv/FsEvent.cpp

@@ -29,10 +29,11 @@ void FsEvent::Start(const Twine& path, unsigned int flags) {
       &uv_fs_event_start, GetRaw(),
       [](uv_fs_event_t* handle, const char* filename, int events, int status) {
         FsEvent& h = *static_cast<FsEvent*>(handle->data);
-        if (status < 0)
+        if (status < 0) {
           h.ReportError(status);
-        else
+        } else {
           h.fsEvent(filename, events);
+        }
       },
       path.toNullTerminatedStringRef(pathBuf).data(), flags);
 }

wpiutil/src/main/native/cpp/uv/GetAddrInfo.cpp

@@ -23,10 +23,11 @@ void GetAddrInfo(Loop& loop, const std::shared_ptr<GetAddrInfoReq>& req,
       loop.GetRaw(), req->GetRaw(),
       [](uv_getaddrinfo_t* req, int status, addrinfo* res) {
         auto& h = *static_cast<GetAddrInfoReq*>(req->data);
-        if (status < 0)
+        if (status < 0) {
           h.ReportError(status);
-        else
+        } else {
           h.resolved(*res);
+        }
         uv_freeaddrinfo(res);
         h.Release();  // this is always a one-shot
       },
@@ -34,10 +35,11 @@ void GetAddrInfo(Loop& loop, const std::shared_ptr<GetAddrInfoReq>& req,
       service.isNull() ? nullptr
                        : service.toNullTerminatedStringRef(serviceStr).data(),
       hints);
-  if (err < 0)
+  if (err < 0) {
     loop.ReportError(err);
-  else
+  } else {
     req->Keep();
+  }
 }
 
 void GetAddrInfo(Loop& loop, std::function<void(const addrinfo&)> callback,

wpiutil/src/main/native/cpp/uv/GetNameInfo.cpp

@@ -21,17 +21,19 @@ void GetNameInfo(Loop& loop, const std::shared_ptr<GetNameInfoReq>& req,
       [](uv_getnameinfo_t* req, int status, const char* hostname,
          const char* service) {
         auto& h = *static_cast<GetNameInfoReq*>(req->data);
-        if (status < 0)
+        if (status < 0) {
           h.ReportError(status);
-        else
+        } else {
           h.resolved(hostname, service);
+        }
         h.Release();  // this is always a one-shot
       },
       &addr, flags);
-  if (err < 0)
+  if (err < 0) {
     loop.ReportError(err);
-  else
+  } else {
     req->Keep();
+  }
 }
 
 void GetNameInfo(Loop& loop,
@@ -46,10 +48,11 @@ void GetNameInfo4(Loop& loop, const std::shared_ptr<GetNameInfoReq>& req,
                   const Twine& ip, unsigned int port, int flags) {
   sockaddr_in addr;
   int err = NameToAddr(ip, port, &addr);
-  if (err < 0)
+  if (err < 0) {
     loop.ReportError(err);
-  else
+  } else {
     GetNameInfo(loop, req, reinterpret_cast<const sockaddr&>(addr), flags);
+  }
 }
 
 void GetNameInfo4(Loop& loop,
@@ -57,20 +60,22 @@ void GetNameInfo4(Loop& loop,
                   const Twine& ip, unsigned int port, int flags) {
   sockaddr_in addr;
   int err = NameToAddr(ip, port, &addr);
-  if (err < 0)
+  if (err < 0) {
     loop.ReportError(err);
-  else
+  } else {
     GetNameInfo(loop, callback, reinterpret_cast<const sockaddr&>(addr), flags);
+  }
 }
 
 void GetNameInfo6(Loop& loop, const std::shared_ptr<GetNameInfoReq>& req,
                   const Twine& ip, unsigned int port, int flags) {
   sockaddr_in6 addr;
   int err = NameToAddr(ip, port, &addr);
-  if (err < 0)
+  if (err < 0) {
     loop.ReportError(err);
-  else
+  } else {
     GetNameInfo(loop, req, reinterpret_cast<const sockaddr&>(addr), flags);
+  }
 }
 
 void GetNameInfo6(Loop& loop,
@@ -78,10 +83,11 @@ void GetNameInfo6(Loop& loop,
                   const Twine& ip, unsigned int port, int flags) {
   sockaddr_in6 addr;
   int err = NameToAddr(ip, port, &addr);
-  if (err < 0)
+  if (err < 0) {
     loop.ReportError(err);
-  else
+  } else {
     GetNameInfo(loop, callback, reinterpret_cast<const sockaddr&>(addr), flags);
+  }
 }
 
 }  // namespace uv

wpiutil/src/main/native/cpp/uv/Handle.cpp

@@ -30,4 +30,6 @@ void Handle::AllocBuf(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
   *buf = h.m_allocBuf(size);
 }
 
-void Handle::DefaultFreeBuf(Buffer& buf) { buf.Deallocate(); }
+void Handle::DefaultFreeBuf(Buffer& buf) {
+  buf.Deallocate();
+}

wpiutil/src/main/native/cpp/uv/Loop.cpp

@@ -26,7 +26,9 @@ Loop::~Loop() noexcept {
 
 std::shared_ptr<Loop> Loop::Create() {
   auto loop = std::make_shared<Loop>(private_init{});
-  if (uv_loop_init(&loop->m_loopStruct) < 0) return nullptr;
+  if (uv_loop_init(&loop->m_loopStruct) < 0) {
+    return nullptr;
+  }
   loop->m_loop = &loop->m_loopStruct;
   loop->m_loop->data = loop.get();
   return loop;
@@ -35,14 +37,18 @@ std::shared_ptr<Loop> Loop::Create() {
 std::shared_ptr<Loop> Loop::GetDefault() {
   static std::shared_ptr<Loop> loop = std::make_shared<Loop>(private_init{});
   loop->m_loop = uv_default_loop();
-  if (!loop->m_loop) return nullptr;
+  if (!loop->m_loop) {
+    return nullptr;
+  }
   loop->m_loop->data = loop.get();
   return loop;
 }
 
 void Loop::Close() {
   int err = uv_loop_close(m_loop);
-  if (err < 0) ReportError(err);
+  if (err < 0) {
+    ReportError(err);
+  }
 }
 
 void Loop::Walk(std::function<void(Handle&)> callback) {
@@ -58,5 +64,7 @@ void Loop::Walk(std::function<void(Handle&)> callback) {
 
 void Loop::Fork() {
   int err = uv_loop_fork(m_loop);
-  if (err < 0) ReportError(err);
+  if (err < 0) {
+    ReportError(err);
+  }
 }

wpiutil/src/main/native/cpp/uv/NetworkStream.cpp

@@ -15,10 +15,11 @@ void NetworkStream::Listen(int backlog) {
   Invoke(&uv_listen, GetRawStream(), backlog,
          [](uv_stream_t* handle, int status) {
            auto& h = *static_cast<NetworkStream*>(handle->data);
-           if (status < 0)
+           if (status < 0) {
              h.ReportError(status);
-           else
+           } else {
              h.connection();
+           }
          });
 }
 

wpiutil/src/main/native/cpp/uv/Pipe.cpp

@@ -23,13 +23,19 @@ std::shared_ptr<Pipe> Pipe::Create(Loop& loop, bool ipc) {
 }
 
 void Pipe::Reuse(std::function<void()> callback, bool ipc) {
-  if (IsClosing()) return;
-  if (!m_reuseData) m_reuseData = std::make_unique<ReuseData>();
+  if (IsClosing()) {
+    return;
+  }
+  if (!m_reuseData) {
+    m_reuseData = std::make_unique<ReuseData>();
+  }
   m_reuseData->callback = callback;
   m_reuseData->ipc = ipc;
   uv_close(GetRawHandle(), [](uv_handle_t* handle) {
     Pipe& h = *static_cast<Pipe*>(handle->data);
-    if (!h.m_reuseData) return;
+    if (!h.m_reuseData) {
+      return;
+    }
     auto data = std::move(h.m_reuseData);
     auto err =
         uv_pipe_init(h.GetLoopRef().GetRaw(), h.GetRaw(), data->ipc ? 1 : 0);
@@ -43,7 +49,9 @@ void Pipe::Reuse(std::function<void()> callback, bool ipc) {
 
 std::shared_ptr<Pipe> Pipe::Accept() {
   auto client = Create(GetLoopRef(), GetRaw()->ipc);
-  if (!client) return nullptr;
+  if (!client) {
+    return nullptr;
+  }
   if (!Accept(client)) {
     client->Release();
     return nullptr;
@@ -51,7 +59,9 @@ std::shared_ptr<Pipe> Pipe::Accept() {
   return client;
 }
 
-Pipe* Pipe::DoAccept() { return Accept().get(); }
+Pipe* Pipe::DoAccept() {
+  return Accept().get();
+}
 
 void Pipe::Bind(const Twine& name) {
   SmallString<128> nameBuf;
@@ -66,10 +76,11 @@ void Pipe::Connect(const Twine& name,
                   name.toNullTerminatedStringRef(nameBuf).data(),
                   [](uv_connect_t* req, int status) {
                     auto& h = *static_cast<PipeConnectReq*>(req->data);
-                    if (status < 0)
+                    if (status < 0) {
                       h.ReportError(status);
-                    else
+                    } else {
                       h.connected();
+                    }
                     h.Release();  // this is always a one-shot
                   });
   req->Keep();

wpiutil/src/main/native/cpp/uv/Poll.cpp

@@ -32,14 +32,20 @@ std::shared_ptr<Poll> Poll::CreateSocket(Loop& loop, uv_os_sock_t sock) {
 }
 
 void Poll::Reuse(int fd, std::function<void()> callback) {
-  if (IsClosing()) return;
-  if (!m_reuseData) m_reuseData = std::make_unique<ReuseData>();
+  if (IsClosing()) {
+    return;
+  }
+  if (!m_reuseData) {
+    m_reuseData = std::make_unique<ReuseData>();
+  }
   m_reuseData->callback = callback;
   m_reuseData->isSocket = false;
   m_reuseData->fd = fd;
   uv_close(GetRawHandle(), [](uv_handle_t* handle) {
     Poll& h = *static_cast<Poll*>(handle->data);
-    if (!h.m_reuseData || h.m_reuseData->isSocket) return;  // just in case
+    if (!h.m_reuseData || h.m_reuseData->isSocket) {
+      return;  // just in case
+    }
     auto data = std::move(h.m_reuseData);
     int err = uv_poll_init(h.GetLoopRef().GetRaw(), h.GetRaw(), data->fd);
     if (err < 0) {
@@ -51,14 +57,20 @@ void Poll::Reuse(int fd, std::function<void()> callback) {
 }
 
 void Poll::ReuseSocket(uv_os_sock_t sock, std::function<void()> callback) {
-  if (IsClosing()) return;
-  if (!m_reuseData) m_reuseData = std::make_unique<ReuseData>();
+  if (IsClosing()) {
+    return;
+  }
+  if (!m_reuseData) {
+    m_reuseData = std::make_unique<ReuseData>();
+  }
   m_reuseData->callback = callback;
   m_reuseData->isSocket = true;
   m_reuseData->sock = sock;
   uv_close(GetRawHandle(), [](uv_handle_t* handle) {
     Poll& h = *static_cast<Poll*>(handle->data);
-    if (!h.m_reuseData || !h.m_reuseData->isSocket) return;  // just in case
+    if (!h.m_reuseData || !h.m_reuseData->isSocket) {
+      return;  // just in case
+    }
     auto data = std::move(h.m_reuseData);
     int err = uv_poll_init(h.GetLoopRef().GetRaw(), h.GetRaw(), data->sock);
     if (err < 0) {
@@ -73,10 +85,11 @@ void Poll::Start(int events) {
   Invoke(&uv_poll_start, GetRaw(), events,
          [](uv_poll_t* handle, int status, int events) {
            Poll& h = *static_cast<Poll*>(handle->data);
-           if (status < 0)
+           if (status < 0) {
              h.ReportError(status);
-           else
+           } else {
              h.pollEvent(events);
+           }
          });
 }
 

wpiutil/src/main/native/cpp/uv/Process.cpp

@@ -65,28 +65,36 @@ std::shared_ptr<Process> Process::SpawnArray(Loop& loop, const Twine& file,
         break;
       case Option::kStdioIgnore: {
         size_t index = o.m_data.stdio.index;
-        if (index >= stdioBuf.size()) stdioBuf.resize(index + 1);
+        if (index >= stdioBuf.size()) {
+          stdioBuf.resize(index + 1);
+        }
         stdioBuf[index].flags = UV_IGNORE;
         stdioBuf[index].data.fd = 0;
         break;
       }
       case Option::kStdioInheritFd: {
         size_t index = o.m_data.stdio.index;
-        if (index >= stdioBuf.size()) stdioBuf.resize(index + 1);
+        if (index >= stdioBuf.size()) {
+          stdioBuf.resize(index + 1);
+        }
         stdioBuf[index].flags = UV_INHERIT_FD;
         stdioBuf[index].data.fd = o.m_data.stdio.fd;
         break;
       }
       case Option::kStdioInheritPipe: {
         size_t index = o.m_data.stdio.index;
-        if (index >= stdioBuf.size()) stdioBuf.resize(index + 1);
+        if (index >= stdioBuf.size()) {
+          stdioBuf.resize(index + 1);
+        }
         stdioBuf[index].flags = UV_INHERIT_STREAM;
         stdioBuf[index].data.stream = o.m_data.stdio.pipe->GetRawStream();
         break;
       }
       case Option::kStdioCreatePipe: {
         size_t index = o.m_data.stdio.index;
-        if (index >= stdioBuf.size()) stdioBuf.resize(index + 1);
+        if (index >= stdioBuf.size()) {
+          stdioBuf.resize(index + 1);
+        }
         stdioBuf[index].flags =
             static_cast<uv_stdio_flags>(UV_CREATE_PIPE | o.m_data.stdio.flags);
         stdioBuf[index].data.stream = o.m_data.stdio.pipe->GetRawStream();
@@ -97,7 +105,9 @@ std::shared_ptr<Process> Process::SpawnArray(Loop& loop, const Twine& file,
     }
   }
 
-  if (argsBuf.empty()) argsBuf.push_back(const_cast<char*>(coptions.file));
+  if (argsBuf.empty()) {
+    argsBuf.push_back(const_cast<char*>(coptions.file));
+  }
   argsBuf.push_back(nullptr);
   coptions.args = argsBuf.data();
 

wpiutil/src/main/native/cpp/uv/Stream.cpp

@@ -38,18 +38,22 @@ void Stream::Shutdown(const std::shared_ptr<ShutdownReq>& req) {
   if (Invoke(&uv_shutdown, req->GetRaw(), GetRawStream(),
              [](uv_shutdown_t* req, int status) {
                auto& h = *static_cast<ShutdownReq*>(req->data);
-               if (status < 0)
+               if (status < 0) {
                  h.ReportError(status);
-               else
+               } else {
                  h.complete();
+               }
                h.Release();  // this is always a one-shot
-             }))
+             })) {
     req->Keep();
+  }
 }
 
 void Stream::Shutdown(std::function<void()> callback) {
   auto req = std::make_shared<ShutdownReq>();
-  if (callback) req->complete.connect(callback);
+  if (callback) {
+    req->complete.connect(callback);
+  }
   Shutdown(req);
 }
 
@@ -60,12 +64,13 @@ void Stream::StartRead() {
            Buffer data = *buf;
 
            // nread=0 is simply ignored
-           if (nread == UV_EOF)
+           if (nread == UV_EOF) {
              h.end();
-           else if (nread > 0)
+           } else if (nread > 0) {
              h.data(data, static_cast<size_t>(nread));
-           else if (nread < 0)
+           } else if (nread < 0) {
              h.ReportError(nread);
+           }
 
            // free the buffer
            h.FreeBuf(data);
@@ -77,11 +82,14 @@ void Stream::Write(ArrayRef<Buffer> bufs,
   if (Invoke(&uv_write, req->GetRaw(), GetRawStream(), bufs.data(), bufs.size(),
              [](uv_write_t* r, int status) {
                auto& h = *static_cast<WriteReq*>(r->data);
-               if (status < 0) h.ReportError(status);
+               if (status < 0) {
+                 h.ReportError(status);
+               }
                h.finish(Error(status));
                h.Release();  // this is always a one-shot
-             }))
+             })) {
     req->Keep();
+  }
 }
 
 void Stream::Write(

wpiutil/src/main/native/cpp/uv/Tcp.cpp

@@ -23,13 +23,19 @@ std::shared_ptr<Tcp> Tcp::Create(Loop& loop, unsigned int flags) {
 }
 
 void Tcp::Reuse(std::function<void()> callback, unsigned int flags) {
-  if (IsClosing()) return;
-  if (!m_reuseData) m_reuseData = std::make_unique<ReuseData>();
+  if (IsClosing()) {
+    return;
+  }
+  if (!m_reuseData) {
+    m_reuseData = std::make_unique<ReuseData>();
+  }
   m_reuseData->callback = callback;
   m_reuseData->flags = flags;
   uv_close(GetRawHandle(), [](uv_handle_t* handle) {
     Tcp& h = *static_cast<Tcp*>(handle->data);
-    if (!h.m_reuseData) return;  // just in case
+    if (!h.m_reuseData) {
+      return;  // just in case
+    }
     auto data = std::move(h.m_reuseData);
     int err = uv_tcp_init_ex(h.GetLoopRef().GetRaw(), h.GetRaw(), data->flags);
     if (err < 0) {
@@ -42,7 +48,9 @@ void Tcp::Reuse(std::function<void()> callback, unsigned int flags) {
 
 std::shared_ptr<Tcp> Tcp::Accept() {
   auto client = Create(GetLoopRef());
-  if (!client) return nullptr;
+  if (!client) {
+    return nullptr;
+  }
   if (!Accept(client)) {
     client->Release();
     return nullptr;
@@ -50,32 +58,37 @@ std::shared_ptr<Tcp> Tcp::Accept() {
   return client;
 }
 
-Tcp* Tcp::DoAccept() { return Accept().get(); }
+Tcp* Tcp::DoAccept() {
+  return Accept().get();
+}
 
 void Tcp::Bind(const Twine& ip, unsigned int port, unsigned int flags) {
   sockaddr_in addr;
   int err = NameToAddr(ip, port, &addr);
-  if (err < 0)
+  if (err < 0) {
     ReportError(err);
-  else
+  } else {
     Bind(reinterpret_cast<const sockaddr&>(addr), flags);
+  }
 }
 
 void Tcp::Bind6(const Twine& ip, unsigned int port, unsigned int flags) {
   sockaddr_in6 addr;
   int err = NameToAddr(ip, port, &addr);
-  if (err < 0)
+  if (err < 0) {
     ReportError(err);
-  else
+  } else {
     Bind(reinterpret_cast<const sockaddr&>(addr), flags);
+  }
 }
 
 sockaddr_storage Tcp::GetSock() {
   sockaddr_storage name;
   int len = sizeof(name);
   if (!Invoke(&uv_tcp_getsockname, GetRaw(), reinterpret_cast<sockaddr*>(&name),
-              &len))
+              &len)) {
     std::memset(&name, 0, sizeof(name));
+  }
   return name;
 }
 
@@ -83,8 +96,9 @@ sockaddr_storage Tcp::GetPeer() {
   sockaddr_storage name;
   int len = sizeof(name);
   if (!Invoke(&uv_tcp_getpeername, GetRaw(), reinterpret_cast<sockaddr*>(&name),
-              &len))
+              &len)) {
     std::memset(&name, 0, sizeof(name));
+  }
   return name;
 }
 
@@ -93,13 +107,15 @@ void Tcp::Connect(const sockaddr& addr,
   if (Invoke(&uv_tcp_connect, req->GetRaw(), GetRaw(), &addr,
              [](uv_connect_t* req, int status) {
                auto& h = *static_cast<TcpConnectReq*>(req->data);
-               if (status < 0)
+               if (status < 0) {
                  h.ReportError(status);
-               else
+               } else {
                  h.connected();
+               }
                h.Release();  // this is always a one-shot
-             }))
+             })) {
     req->Keep();
+  }
 }
 
 void Tcp::Connect(const sockaddr& addr, std::function<void()> callback) {
@@ -112,40 +128,44 @@ void Tcp::Connect(const Twine& ip, unsigned int port,
                   const std::shared_ptr<TcpConnectReq>& req) {
   sockaddr_in addr;
   int err = NameToAddr(ip, port, &addr);
-  if (err < 0)
+  if (err < 0) {
     ReportError(err);
-  else
+  } else {
     Connect(reinterpret_cast<const sockaddr&>(addr), req);
+  }
 }
 
 void Tcp::Connect(const Twine& ip, unsigned int port,
                   std::function<void()> callback) {
   sockaddr_in addr;
   int err = NameToAddr(ip, port, &addr);
-  if (err < 0)
+  if (err < 0) {
     ReportError(err);
-  else
+  } else {
     Connect(reinterpret_cast<const sockaddr&>(addr), callback);
+  }
 }
 
 void Tcp::Connect6(const Twine& ip, unsigned int port,
                    const std::shared_ptr<TcpConnectReq>& req) {
   sockaddr_in6 addr;
   int err = NameToAddr(ip, port, &addr);
-  if (err < 0)
+  if (err < 0) {
     ReportError(err);
-  else
+  } else {
     Connect(reinterpret_cast<const sockaddr&>(addr), req);
+  }
 }
 
 void Tcp::Connect6(const Twine& ip, unsigned int port,
                    std::function<void()> callback) {
   sockaddr_in6 addr;
   int err = NameToAddr(ip, port, &addr);
-  if (err < 0)
+  if (err < 0) {
     ReportError(err);
-  else
+  } else {
     Connect(reinterpret_cast<const sockaddr&>(addr), callback);
+  }
 }
 
 }  // namespace uv

wpiutil/src/main/native/cpp/uv/Timer.cpp

@@ -22,7 +22,9 @@ std::shared_ptr<Timer> Timer::Create(Loop& loop) {
 
 void Timer::SingleShot(Loop& loop, Time timeout, std::function<void()> func) {
   auto h = Create(loop);
-  if (!h) return;
+  if (!h) {
+    return;
+  }
   h->timeout.connect([theTimer = h.get(), func]() {
     func();
     theTimer->Close();

wpiutil/src/main/native/cpp/uv/Udp.cpp

@@ -51,45 +51,50 @@ std::shared_ptr<Udp> Udp::Create(Loop& loop, unsigned int flags) {
 void Udp::Bind(const Twine& ip, unsigned int port, unsigned int flags) {
   sockaddr_in addr;
   int err = NameToAddr(ip, port, &addr);
-  if (err < 0)
+  if (err < 0) {
     ReportError(err);
-  else
+  } else {
     Bind(reinterpret_cast<const sockaddr&>(addr), flags);
+  }
 }
 
 void Udp::Bind6(const Twine& ip, unsigned int port, unsigned int flags) {
   sockaddr_in6 addr;
   int err = NameToAddr(ip, port, &addr);
-  if (err < 0)
+  if (err < 0) {
     ReportError(err);
-  else
+  } else {
     Bind(reinterpret_cast<const sockaddr&>(addr), flags);
+  }
 }
 
 void Udp::Connect(const Twine& ip, unsigned int port) {
   sockaddr_in addr;
   int err = NameToAddr(ip, port, &addr);
-  if (err < 0)
+  if (err < 0) {
     ReportError(err);
-  else
+  } else {
     Connect(reinterpret_cast<const sockaddr&>(addr));
+  }
 }
 
 void Udp::Connect6(const Twine& ip, unsigned int port) {
   sockaddr_in6 addr;
   int err = NameToAddr(ip, port, &addr);
-  if (err < 0)
+  if (err < 0) {
     ReportError(err);
-  else
+  } else {
     Connect(reinterpret_cast<const sockaddr&>(addr));
+  }
 }
 
 sockaddr_storage Udp::GetPeer() {
   sockaddr_storage name;
   int len = sizeof(name);
   if (!Invoke(&uv_udp_getpeername, GetRaw(), reinterpret_cast<sockaddr*>(&name),
-              &len))
+              &len)) {
     std::memset(&name, 0, sizeof(name));
+  }
   return name;
 }
 
@@ -97,8 +102,9 @@ sockaddr_storage Udp::GetSock() {
   sockaddr_storage name;
   int len = sizeof(name);
   if (!Invoke(&uv_udp_getsockname, GetRaw(), reinterpret_cast<sockaddr*>(&name),
-              &len))
+              &len)) {
     std::memset(&name, 0, sizeof(name));
+  }
   return name;
 }
 
@@ -123,11 +129,14 @@ void Udp::Send(const sockaddr& addr, ArrayRef<Buffer> bufs,
   if (Invoke(&uv_udp_send, req->GetRaw(), GetRaw(), bufs.data(), bufs.size(),
              &addr, [](uv_udp_send_t* r, int status) {
                auto& h = *static_cast<UdpSendReq*>(r->data);
-               if (status < 0) h.ReportError(status);
+               if (status < 0) {
+                 h.ReportError(status);
+               }
                h.complete(Error(status));
                h.Release();  // this is always a one-shot
-             }))
+             })) {
     req->Keep();
+  }
 }
 
 void Udp::Send(const sockaddr& addr, ArrayRef<Buffer> bufs,
@@ -139,11 +148,14 @@ void Udp::Send(ArrayRef<Buffer> bufs, const std::shared_ptr<UdpSendReq>& req) {
   if (Invoke(&uv_udp_send, req->GetRaw(), GetRaw(), bufs.data(), bufs.size(),
              nullptr, [](uv_udp_send_t* r, int status) {
                auto& h = *static_cast<UdpSendReq*>(r->data);
-               if (status < 0) h.ReportError(status);
+               if (status < 0) {
+                 h.ReportError(status);
+               }
                h.complete(Error(status));
                h.Release();  // this is always a one-shot
-             }))
+             })) {
     req->Keep();
+  }
 }
 
 void Udp::Send(ArrayRef<Buffer> bufs,
@@ -159,10 +171,11 @@ void Udp::StartRecv() {
            Buffer data = *buf;
 
            // nread=0 is simply ignored
-           if (nread > 0)
+           if (nread > 0) {
              h.received(data, static_cast<size_t>(nread), *addr, flags);
-           else if (nread < 0)
+           } else if (nread < 0) {
              h.ReportError(nread);
+           }
 
            // free the buffer
            h.FreeBuf(data);

wpiutil/src/main/native/cpp/uv/Work.cpp

@@ -22,23 +22,29 @@ void QueueWork(Loop& loop, const std::shared_ptr<WorkReq>& req) {
       },
       [](uv_work_t* req, int status) {
         auto& h = *static_cast<WorkReq*>(req->data);
-        if (status < 0)
+        if (status < 0) {
           h.ReportError(status);
-        else
+        } else {
           h.afterWork();
+        }
         h.Release();  // this is always a one-shot
       });
-  if (err < 0)
+  if (err < 0) {
     loop.ReportError(err);
-  else
+  } else {
     req->Keep();
+  }
 }
 
 void QueueWork(Loop& loop, std::function<void()> work,
                std::function<void()> afterWork) {
   auto req = std::make_shared<WorkReq>();
-  if (work) req->work.connect(work);
-  if (afterWork) req->afterWork.connect(afterWork);
+  if (work) {
+    req->work.connect(work);
+  }
+  if (afterWork) {
+    req->afterWork.connect(afterWork);
+  }
   QueueWork(loop, req);
 }