[ORC] clang-format code that was touched in r267457. NFC.

Commit r267457 made a lot of type-substitutions threw off code formatting and
alignment. This patch should tidy those changes up.

llvm-svn: 267475

4 files changed, 80 insertions, 99 deletions

diff --git a/llvm/include/llvm-c/OrcBindings.h b/llvm/include/llvm-c/OrcBindings.h
index 4a2fa26abd4..de2969ab1c9 100644
--- a/llvm/include/llvm-c/OrcBindings.h
+++ b/llvm/include/llvm-c/OrcBindings.h
@@ -32,15 +32,11 @@ extern "C" {
 typedef struct LLVMOrcOpaqueJITStack *LLVMOrcJITStackRef;
 typedef uint32_t LLVMOrcModuleHandle;
 typedef uint64_t LLVMOrcTargetAddress;
-typedef uint64_t (*LLVMOrcSymbolResolverFn)(const char *Name,
-                                            void *LookupCtx);
+typedef uint64_t (*LLVMOrcSymbolResolverFn)(const char *Name, void *LookupCtx);
 typedef uint64_t (*LLVMOrcLazyCompileCallbackFn)(LLVMOrcJITStackRef JITStack,
                                                  void *CallbackCtx);
 
-typedef enum {
-  LLVMOrcErrSuccess = 0,
-  LLVMOrcErrGeneric
-} LLVMOrcErrorCode;
+typedef enum { LLVMOrcErrSuccess = 0, LLVMOrcErrGeneric } LLVMOrcErrorCode;
 
 /**
  * Create an ORC JIT stack.
@@ -114,10 +110,10 @@ LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack, LLVMModuleRef Mod,
 /**
  * Add an object file.
  */
-LLVMOrcModuleHandle
-LLVMOrcAddObjectFile(LLVMOrcJITStackRef JITStack, LLVMObjectFileRef Obj,
-                     LLVMOrcSymbolResolverFn SymbolResolver,
-                     void *SymbolResolverCtx);
+LLVMOrcModuleHandle LLVMOrcAddObjectFile(LLVMOrcJITStackRef JITStack,
+                                         LLVMObjectFileRef Obj,
+                                         LLVMOrcSymbolResolverFn SymbolResolver,
+                                         void *SymbolResolverCtx);
 
 /**
  * Remove a module set from the JIT.
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h b/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
index 615d6369a64..03306985a3e 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
@@ -29,7 +29,6 @@ namespace orc {
 /// @brief Target-independent base class for compile callback management.
 class JITCompileCallbackManager {
 public:
-
   typedef std::function<TargetAddress()> CompileFtor;
 
   /// @brief Handle to a newly created compile callback. Can be used to get an
@@ -38,12 +37,13 @@ public:
   class CompileCallbackInfo {
   public:
     CompileCallbackInfo(TargetAddress Addr, CompileFtor &Compile)
-      : Addr(Addr), Compile(Compile) {}
+        : Addr(Addr), Compile(Compile) {}
 
     TargetAddress getAddress() const { return Addr; }
     void setCompileAction(CompileFtor Compile) {
       this->Compile = std::move(Compile);
     }
+
   private:
     TargetAddress Addr;
     CompileFtor &Compile;
@@ -53,7 +53,7 @@ public:
   /// @param ErrorHandlerAddress The address of an error handler in the target
   ///                            process to be used if a compile callback fails.
   JITCompileCallbackManager(TargetAddress ErrorHandlerAddress)
-    : ErrorHandlerAddress(ErrorHandlerAddress) {}
+      : ErrorHandlerAddress(ErrorHandlerAddress) {}
 
   virtual ~JITCompileCallbackManager() {}
 
@@ -69,8 +69,10 @@ public:
     // Found a callback handler. Yank this trampoline out of the active list and
     // put it back in the available trampolines list, then try to run the
     // handler's compile and update actions.
-    // Moving the trampoline ID back to the available list first means there's at
-    // least one available trampoline if the compile action triggers a request for
+    // Moving the trampoline ID back to the available list first means there's
+    // at
+    // least one available trampoline if the compile action triggers a request
+    // for
     // a new one.
     auto Compile = std::move(I->second);
     ActiveTrampolines.erase(I);
@@ -116,7 +118,6 @@ protected:
   std::vector<TargetAddress> AvailableTrampolines;
 
 private:
-
   TargetAddress getAvailableTrampolineAddr() {
     if (this->AvailableTrampolines.empty())
       grow();
@@ -137,20 +138,17 @@ private:
 template <typename TargetT>
 class LocalJITCompileCallbackManager : public JITCompileCallbackManager {
 public:
-
   /// @brief Construct a InProcessJITCompileCallbackManager.
   /// @param ErrorHandlerAddress The address of an error handler in the target
   ///                            process to be used if a compile callback fails.
   LocalJITCompileCallbackManager(TargetAddress ErrorHandlerAddress)
-    : JITCompileCallbackManager(ErrorHandlerAddress) {
+      : JITCompileCallbackManager(ErrorHandlerAddress) {
 
     /// Set up the resolver block.
     std::error_code EC;
-    ResolverBlock =
-      sys::OwningMemoryBlock(
-        sys::Memory::allocateMappedMemory(TargetT::ResolverCodeSize, nullptr,
-                                          sys::Memory::MF_READ |
-                                          sys::Memory::MF_WRITE, EC));
+    ResolverBlock = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
+        TargetT::ResolverCodeSize, nullptr,
+        sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
     assert(!EC && "Failed to allocate resolver block");
 
     TargetT::writeResolverCode(static_cast<uint8_t *>(ResolverBlock.base()),
@@ -163,13 +161,11 @@ public:
   }
 
 private:
-
   static TargetAddress reenter(void *CCMgr, void *TrampolineId) {
     JITCompileCallbackManager *Mgr =
-      static_cast<JITCompileCallbackManager*>(CCMgr);
+        static_cast<JITCompileCallbackManager *>(CCMgr);
     return Mgr->executeCompileCallback(
-             static_cast<TargetAddress>(
-               reinterpret_cast<uintptr_t>(TrampolineId)));
+        static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(TrampolineId)));
   }
 
   void grow() override {
@@ -177,18 +173,16 @@ private:
 
     std::error_code EC;
     auto TrampolineBlock =
-      sys::OwningMemoryBlock(
-        sys::Memory::allocateMappedMemory(sys::Process::getPageSize(), nullptr,
-                                          sys::Memory::MF_READ |
-                                          sys::Memory::MF_WRITE, EC));
+        sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
+            sys::Process::getPageSize(), nullptr,
+            sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
     assert(!EC && "Failed to allocate trampoline block");
 
-
     unsigned NumTrampolines =
-      (sys::Process::getPageSize() - TargetT::PointerSize) /
+        (sys::Process::getPageSize() - TargetT::PointerSize) /
         TargetT::TrampolineSize;
 
-    uint8_t *TrampolineMem = static_cast<uint8_t*>(TrampolineBlock.base());
+    uint8_t *TrampolineMem = static_cast<uint8_t *>(TrampolineBlock.base());
     TargetT::writeTrampolines(TrampolineMem, ResolverBlock.base(),
                               NumTrampolines);
 
@@ -212,7 +206,6 @@ private:
 /// @brief Base class for managing collections of named indirect stubs.
 class IndirectStubsManager {
 public:
-
   /// @brief Map type for initializing the manager. See init.
   typedef StringMap<std::pair<TargetAddress, JITSymbolFlags>> StubInitsMap;
 
@@ -236,6 +229,7 @@ public:
 
   /// @brief Change the value of the implementation pointer for the stub.
   virtual Error updatePointer(StringRef Name, TargetAddress NewAddr) = 0;
+
 private:
   virtual void anchor();
 };
@@ -245,9 +239,8 @@ private:
 template <typename TargetT>
 class LocalIndirectStubsManager : public IndirectStubsManager {
 public:
-
   Error createStub(StringRef StubName, TargetAddress StubAddr,
-                             JITSymbolFlags StubFlags) override {
+                   JITSymbolFlags StubFlags) override {
     if (auto Err = reserveStubs(1))
       return Err;
 
@@ -275,7 +268,7 @@ public:
     void *StubAddr = IndirectStubsInfos[Key.first].getStub(Key.second);
     assert(StubAddr && "Missing stub address");
     auto StubTargetAddr =
-      static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(StubAddr));
+        static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(StubAddr));
     auto StubSymbol = JITSymbol(StubTargetAddr, I->second.second);
     if (ExportedStubsOnly && !StubSymbol.isExported())
       return nullptr;
@@ -290,7 +283,7 @@ public:
     void *PtrAddr = IndirectStubsInfos[Key.first].getPtr(Key.second);
     assert(PtrAddr && "Missing pointer address");
     auto PtrTargetAddr =
-      static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(PtrAddr));
+        static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(PtrAddr));
     return JITSymbol(PtrTargetAddr, I->second.second);
   }
 
@@ -299,12 +292,11 @@ public:
     assert(I != StubIndexes.end() && "No stub pointer for symbol");
     auto Key = I->second.first;
     *IndirectStubsInfos[Key.first].getPtr(Key.second) =
-      reinterpret_cast<void*>(static_cast<uintptr_t>(NewAddr));
+        reinterpret_cast<void *>(static_cast<uintptr_t>(NewAddr));
     return Error::success();
   }
 
 private:
-
   Error reserveStubs(unsigned NumStubs) {
     if (NumStubs <= FreeStubs.size())
       return Error::success();
@@ -312,8 +304,8 @@ private:
     unsigned NewStubsRequired = NumStubs - FreeStubs.size();
     unsigned NewBlockId = IndirectStubsInfos.size();
     typename TargetT::IndirectStubsInfo ISI;
-    if (auto Err = TargetT::emitIndirectStubsBlock(ISI, NewStubsRequired,
-                                                  nullptr))
+    if (auto Err =
+            TargetT::emitIndirectStubsBlock(ISI, NewStubsRequired, nullptr))
       return Err;
     for (unsigned I = 0; I < ISI.getNumStubs(); ++I)
       FreeStubs.push_back(std::make_pair(NewBlockId, I));
@@ -326,7 +318,7 @@ private:
     auto Key = FreeStubs.back();
     FreeStubs.pop_back();
     *IndirectStubsInfos[Key.first].getPtr(Key.second) =
-      reinterpret_cast<void*>(static_cast<uintptr_t>(InitAddr));
+        reinterpret_cast<void *>(static_cast<uintptr_t>(InitAddr));
     StubIndexes[StubName] = std::make_pair(Key, StubFlags);
   }
 
@@ -341,12 +333,12 @@ private:
 ///
 ///   Usage example: Turn a trampoline address into a function pointer constant
 /// for use in a stub.
-Constant* createIRTypedAddress(FunctionType &FT, TargetAddress Addr);
+Constant *createIRTypedAddress(FunctionType &FT, TargetAddress Addr);
 
 /// @brief Create a function pointer with the given type, name, and initializer
 ///        in the given Module.
-GlobalVariable* createImplPointer(PointerType &PT, Module &M,
-                                  const Twine &Name, Constant *Initializer);
+GlobalVariable *createImplPointer(PointerType &PT, Module &M, const Twine &Name,
+                                  Constant *Initializer);
 
 /// @brief Turn a function declaration into a stub function that makes an
 ///        indirect call using the given function pointer.
@@ -371,7 +363,7 @@ void makeAllSymbolsExternallyAccessible(Module &M);
 /// modules with these utilities, all decls should be cloned (and added to a
 /// single VMap) before any bodies are moved. This will ensure that references
 /// between functions all refer to the versions in the new module.
-Function* cloneFunctionDecl(Module &Dst, const Function &F,
+Function *cloneFunctionDecl(Module &Dst, const Function &F,
                             ValueToValueMapTy *VMap = nullptr);
 
 /// @brief Move the body of function 'F' to a cloned function declaration in a
@@ -387,7 +379,7 @@ void moveFunctionBody(Function &OrigF, ValueToValueMapTy &VMap,
                       Function *NewF = nullptr);
 
 /// @brief Clone a global variable declaration into a new module.
-GlobalVariable* cloneGlobalVariableDecl(Module &Dst, const GlobalVariable &GV,
+GlobalVariable *cloneGlobalVariableDecl(Module &Dst, const GlobalVariable &GV,
                                         ValueToValueMapTy *VMap = nullptr);
 
 /// @brief Move global variable GV from its parent module to cloned global
@@ -404,7 +396,7 @@ void moveGlobalVariableInitializer(GlobalVariable &OrigGV,
                                    GlobalVariable *NewGV = nullptr);
 
 /// @brief Clone
-GlobalAlias* cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA,
+GlobalAlias *cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA,
                                   ValueToValueMapTy &VMap);
 
 } // End namespace orc.
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h b/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
index df0b5fe1cf4..74d851522f7 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
@@ -28,19 +28,19 @@ class DirectBufferWriter {
 public:
   DirectBufferWriter() = default;
   DirectBufferWriter(const char *Src, TargetAddress Dst, uint64_t Size)
-    : Src(Src), Dst(Dst), Size(Size) {}
+      : Src(Src), Dst(Dst), Size(Size) {}
 
   const char *getSrc() const { return Src; }
   TargetAddress getDst() const { return Dst; }
   uint64_t getSize() const { return Size; }
+
 private:
   const char *Src;
   TargetAddress Dst;
   uint64_t Size;
 };
 
-inline Error serialize(RPCChannel &C,
-                       const DirectBufferWriter &DBW) {
+inline Error serialize(RPCChannel &C, const DirectBufferWriter &DBW) {
   if (auto EC = serialize(C, DBW.getDst()))
     return EC;
   if (auto EC = serialize(C, DBW.getSize()))
@@ -48,15 +48,14 @@ inline Error serialize(RPCChannel &C,
   return C.appendBytes(DBW.getSrc(), DBW.getSize());
 }
 
-inline Error deserialize(RPCChannel &C,
-                         DirectBufferWriter &DBW) {
+inline Error deserialize(RPCChannel &C, DirectBufferWriter &DBW) {
   TargetAddress Dst;
   if (auto EC = deserialize(C, Dst))
     return EC;
   uint64_t Size;
   if (auto EC = deserialize(C, Size))
     return EC;
-  char *Addr = reinterpret_cast<char*>(static_cast<uintptr_t>(Dst));
+  char *Addr = reinterpret_cast<char *>(static_cast<uintptr_t>(Dst));
 
   DBW = DirectBufferWriter(0, Dst, Size);
 
@@ -65,7 +64,6 @@ inline Error deserialize(RPCChannel &C,
 
 class OrcRemoteTargetRPCAPI : public RPC<RPCChannel> {
 protected:
-
   class ResourceIdMgr {
   public:
     typedef uint64_t ResourceId;
@@ -87,16 +85,13 @@ protected:
   };
 
 public:
-
   // FIXME: Remove constructors once MSVC supports synthesizing move-ops.
   OrcRemoteTargetRPCAPI() = default;
-  OrcRemoteTargetRPCAPI(const OrcRemoteTargetRPCAPI&) = delete;
-  OrcRemoteTargetRPCAPI& operator=(const OrcRemoteTargetRPCAPI&) = delete;
+  OrcRemoteTargetRPCAPI(const OrcRemoteTargetRPCAPI &) = delete;
+  OrcRemoteTargetRPCAPI &operator=(const OrcRemoteTargetRPCAPI &) = delete;
 
-  OrcRemoteTargetRPCAPI(OrcRemoteTargetRPCAPI&&) {}
-  OrcRemoteTargetRPCAPI& operator=(OrcRemoteTargetRPCAPI&&) {
-    return *this;
-  }
+  OrcRemoteTargetRPCAPI(OrcRemoteTargetRPCAPI &&) {}
+  OrcRemoteTargetRPCAPI &operator=(OrcRemoteTargetRPCAPI &&) { return *this; }
 
   enum JITFuncId : uint32_t {
     InvalidId = RPCFunctionIdTraits<JITFuncId>::InvalidId,
@@ -127,80 +122,78 @@ public:
 
   typedef Function<CallIntVoidId, int32_t(TargetAddress Addr)> CallIntVoid;
 
-  typedef Function<CallMainId, int32_t(TargetAddress Addr,
-				       std::vector<std::string> Args)>
+  typedef Function<CallMainId,
+                   int32_t(TargetAddress Addr, std::vector<std::string> Args)>
       CallMain;
 
   typedef Function<CallVoidVoidId, void(TargetAddress FnAddr)> CallVoidVoid;
 
   typedef Function<CreateRemoteAllocatorId,
-		   void(ResourceIdMgr::ResourceId AllocatorID)>
+                   void(ResourceIdMgr::ResourceId AllocatorID)>
       CreateRemoteAllocator;
 
   typedef Function<CreateIndirectStubsOwnerId,
-		   void(ResourceIdMgr::ResourceId StubOwnerID)>
-    CreateIndirectStubsOwner;
+                   void(ResourceIdMgr::ResourceId StubOwnerID)>
+      CreateIndirectStubsOwner;
 
   typedef Function<DeregisterEHFramesId,
-		   void(TargetAddress Addr, uint32_t Size)>
+                   void(TargetAddress Addr, uint32_t Size)>
       DeregisterEHFrames;
 
   typedef Function<DestroyRemoteAllocatorId,
-		   void(ResourceIdMgr::ResourceId AllocatorID)>
+                   void(ResourceIdMgr::ResourceId AllocatorID)>
       DestroyRemoteAllocator;
 
   typedef Function<DestroyIndirectStubsOwnerId,
-		   void(ResourceIdMgr::ResourceId StubsOwnerID)>
+                   void(ResourceIdMgr::ResourceId StubsOwnerID)>
       DestroyIndirectStubsOwner;
 
   /// EmitIndirectStubs result is (StubsBase, PtrsBase, NumStubsEmitted).
   typedef Function<EmitIndirectStubsId,
-		   std::tuple<TargetAddress, TargetAddress, uint32_t>(
-                        ResourceIdMgr::ResourceId StubsOwnerID,
-			uint32_t NumStubsRequired)>
+                   std::tuple<TargetAddress, TargetAddress, uint32_t>(
+                       ResourceIdMgr::ResourceId StubsOwnerID,
+                       uint32_t NumStubsRequired)>
       EmitIndirectStubs;
 
   typedef Function<EmitResolverBlockId, void()> EmitResolverBlock;
 
   /// EmitTrampolineBlock result is (BlockAddr, NumTrampolines).
-  typedef Function<EmitTrampolineBlockId,
-		   std::tuple<TargetAddress, uint32_t>()> EmitTrampolineBlock;
+  typedef Function<EmitTrampolineBlockId, std::tuple<TargetAddress, uint32_t>()>
+      EmitTrampolineBlock;
 
   typedef Function<GetSymbolAddressId, TargetAddress(std::string SymbolName)>
       GetSymbolAddress;
 
   /// GetRemoteInfo result is (Triple, PointerSize, PageSize, TrampolineSize,
   ///                          IndirectStubsSize).
-  typedef Function<GetRemoteInfoId,
-		   std::tuple<std::string, uint32_t, uint32_t, uint32_t,
-			      uint32_t>()> GetRemoteInfo;
+  typedef Function<GetRemoteInfoId, std::tuple<std::string, uint32_t, uint32_t,
+                                               uint32_t, uint32_t>()>
+      GetRemoteInfo;
 
   typedef Function<ReadMemId,
-		   std::vector<char>(TargetAddress Src, uint64_t Size)>
+                   std::vector<char>(TargetAddress Src, uint64_t Size)>
       ReadMem;
 
-  typedef Function<RegisterEHFramesId,
-		   void(TargetAddress Addr, uint32_t Size)>
+  typedef Function<RegisterEHFramesId, void(TargetAddress Addr, uint32_t Size)>
       RegisterEHFrames;
 
   typedef Function<ReserveMemId,
-		   TargetAddress(ResourceIdMgr::ResourceId AllocID,
-				 uint64_t Size, uint32_t Align)>
+                   TargetAddress(ResourceIdMgr::ResourceId AllocID,
+                                 uint64_t Size, uint32_t Align)>
       ReserveMem;
 
   typedef Function<RequestCompileId,
-		   TargetAddress(TargetAddress TrampolineAddr)>
+                   TargetAddress(TargetAddress TrampolineAddr)>
       RequestCompile;
 
   typedef Function<SetProtectionsId,
-		   void(ResourceIdMgr::ResourceId AllocID, TargetAddress Dst,
-			uint32_t ProtFlags)>
+                   void(ResourceIdMgr::ResourceId AllocID, TargetAddress Dst,
+                        uint32_t ProtFlags)>
       SetProtections;
 
   typedef Function<TerminateSessionId, void()> TerminateSession;
 
-  typedef Function<WriteMemId, void(DirectBufferWriter DB)>
-      WriteMem;
+  typedef Function<WriteMemId, void(DirectBufferWriter DB)> WriteMem;
 
   typedef Function<WritePtrId, void(TargetAddress Dst, TargetAddress Val)>
       WritePtr;
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/RPCUtils.h b/llvm/include/llvm/ExecutionEngine/Orc/RPCUtils.h
index ee5ccf98c04..966a4968434 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/RPCUtils.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/RPCUtils.h
@@ -327,25 +327,24 @@ template <typename ChannelT, typename FunctionIdT = uint32_t,
           typename SequenceNumberT = uint16_t>
 class RPC : public RPCBase {
 public:
-
   /// RPC default constructor.
   RPC() = default;
 
   /// RPC instances cannot be copied.
-  RPC(const RPC&) = delete;
+  RPC(const RPC &) = delete;
 
   /// RPC instances cannot be copied.
-  RPC& operator=(const RPC&) = delete;
+  RPC &operator=(const RPC &) = delete;
 
   /// RPC move constructor.
   // FIXME: Remove once MSVC can synthesize move ops.
   RPC(RPC &&Other)
-    : SequenceNumberMgr(std::move(Other.SequenceNumberMgr)),
-      OutstandingResults(std::move(Other.OutstandingResults)) {}
+      : SequenceNumberMgr(std::move(Other.SequenceNumberMgr)),
+        OutstandingResults(std::move(Other.OutstandingResults)) {}
 
   /// RPC move assignment.
   // FIXME: Remove once MSVC can synthesize move ops.
-  RPC& operator=(RPC &&Other) {
+  RPC &operator=(RPC &&Other) {
     SequenceNumberMgr = std::move(Other.SequenceNumberMgr);
     OutstandingResults = std::move(Other.OutstandingResults);
     return *this;
@@ -408,7 +407,7 @@ public:
         createOutstandingResult<Func>(std::move(Promise));
 
     if (auto Err = CallHelper<ChannelT, SequenceNumberT, Func>::call(C, SeqNo,
-                                                                    Args...)) {
+                                                                     Args...)) {
       abandonOutstandingResults();
       return std::move(Err);
     } else
@@ -435,7 +434,7 @@ public:
   /// std::future<Optional<T>> (or a future<bool> for void functions).
   template <typename Func, typename... ArgTs>
   Expected<AsyncCallResult<Func>> appendCallAsync(ChannelT &C,
-                                                 const ArgTs &... Args) {
+                                                  const ArgTs &... Args) {
     auto ResAndSeqOrErr = appendCallAsyncWithSeq<Func>(C, Args...);
     if (ResAndSeqOrErr)
       return std::move(ResAndSeqOrErr->first);
@@ -445,7 +444,8 @@ public:
   /// The same as appendCallAsync, except that it calls C.send to flush the
   /// channel after serializing the call.
   template <typename Func, typename... ArgTs>
-  Expected<AsyncCallResult<Func>> callAsync(ChannelT &C, const ArgTs &... Args) {
+  Expected<AsyncCallResult<Func>> callAsync(ChannelT &C,
+                                            const ArgTs &... Args) {
     auto ResAndSeqOrErr = callAsyncWithSeq<Func>(C, Args...);
     if (ResAndSeqOrErr)
       return std::move(ResAndSeqOrErr->first);