Apply pre-commit formatting fixes

clang-format and prettier auto-formatting adjustments.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: pratikmankawde

BoostToStdCoroutineSwitchPlan.md

@@ -108,6 +108,7 @@ C++20 stackless coroutines have well-known limitations compared to stackful coro
 **Claim**: Stackless coroutines cannot yield from arbitrary stack depths. If `fn_a()` calls `fn_b()` calls `yield()`, only stackful coroutines can suspend the entire chain.
 
 **Analysis**: An exhaustive codebase audit found:
+
 - **1 production yield() call**: `RipplePathFind.cpp:131` — directly in the handler function body
 - **All test yield() calls**: directly in `postCoro` lambda bodies (Coroutine_test.cpp, JobQueue_test.cpp)
 - **The `push_type*` architecture** makes deep-nested yield() structurally impossible — the `yield_` pointer is only available inside the `postCoro` lambda via the `shared_ptr<Coro>`, and handlers call `context.coro->yield()` at the top level
@@ -119,6 +120,7 @@ C++20 stackless coroutines have well-known limitations compared to stackful coro
 **Claim**: Once a function needs to suspend, every caller up the chain must also be a coroutine. This "infects" the call chain.
 
 **Analysis**: In rippled's case, the coloring is minimal:
+
 - `postCoroTask()` launches a coroutine — this is the "root" colored function
 - The `postCoro` lambda itself becomes the coroutine function (returns `CoroTask<void>`)
 - `doRipplePathFind()` is the only handler that calls `co_await`
@@ -133,6 +135,7 @@ The "coloring" stops at the entry point lambda and the one handler that suspends
 **Claim**: C++20 provides the language primitives but no standard task type, executor integration, or composition utilities.
 
 **Analysis**: This is accurate — we need to write custom types:
+
 - `CoroTask<T>` (task/return type) — well-established pattern, ~80 lines
 - `JobQueueAwaiter` (executor integration) — ~20 lines
 - `FinalAwaiter` (continuation chaining) — ~10 lines
@@ -154,6 +157,7 @@ However, these types are small, well-understood, and have extensive reference im
 **Claim**: Coroutine frames are heap-allocated and outlive the calling scope, making references to locals dangerous.
 
 **Analysis**: This is a real concern that requires engineering discipline:
+
 - Coroutine parameters are copied into the frame (safe by default)
 - References passed to coroutine functions can dangle if the referent's scope ends before the coroutine completes
 - Our design mitigates this: `RPC::Context` is passed by reference but its lifetime is managed by `shared_ptr<Coro>` / the entry point lambda's scope, which outlives the coroutine
@@ -165,6 +169,7 @@ However, these types are small, well-understood, and have extensive reference im
 **Claim**: `yield_to.h:111` uses `boost::asio::spawn`, suggesting broader coroutine usage.
 
 **Analysis**: `yield_to.h` uses `boost::asio::spawn` with `boost::context::fixedsize_stack(2 * 1024 * 1024)` — this is a **completely separate** coroutine system:
+
 - Different type: `boost::asio::yield_context` (not `push_type*`)
 - Different purpose: test infrastructure for async I/O tests
 - Different mechanism: Boost.Asio stackful coroutines (not Boost.Coroutine2)
@@ -175,6 +180,7 @@ However, these types are small, well-understood, and have extensive reference im
 #### Overall Viability Conclusion
 
 The migration IS viable because:
+
 1. rippled's coroutine usage is **shallow** (no deep-nested yield)
 2. The **colored function infection** is limited to 4 call sites
 3. Custom types are **small and well-understood**
@@ -207,6 +213,7 @@ The migration IS viable because:
 #### Alternative Considered: ASAN Annotations Only
 
 Instead of full migration, one could keep Boost.Coroutine and add `__sanitizer_start_switch_fiber` / `__sanitizer_finish_switch_fiber` annotations to Coro.ipp to suppress ASAN false positives. This was evaluated and rejected because:
+
 - It only fixes sanitizer false positives — does NOT reduce 1MB/coroutine memory usage
 - Does NOT remove the deprecated Boost.Coroutine dependency
 - Does NOT provide standard compliance or future-proofing
@@ -400,18 +407,21 @@ Coroutine    = std::function<void(Suspend)>    — given a Suspend, starts work
 ```
 
 In practice, `JobQueue::Coro` simplifies this to:
+
 - **Suspend** = `coro->yield()`
 - **Continue** = `coro->post()` (async on JobQueue) or `coro->resume()` (sync on current thread)
 
 ### 2.6 CMake Dependency
 
 In `cmake/deps/Boost.cmake`:
+
 ```cmake
 find_package(Boost REQUIRED COMPONENTS ... coroutine ...)
 target_link_libraries(xrpl_boost INTERFACE ... Boost::coroutine ...)
 ```
 
 Additionally in `cmake/XrplInterface.cmake`:
+
 ```cpp
 BOOST_COROUTINES_NO_DEPRECATION_WARNING  // Suppresses Boost.Coroutine deprecation warnings
 ```
@@ -433,6 +443,7 @@ rippled **already uses C++20 coroutines** in test code:
 **Decision: Incremental (multi-phase) migration.**
 
 Rationale:
+
 - Only **one RPC handler** (`RipplePathFind`) actively uses `yield()/post()` suspension
 - The **three entry points** (HTTP, WS, gRPC) all funnel through `postCoro()`
 - The `RPC::Context.coro` field is the sole propagation mechanism
@@ -689,6 +700,7 @@ sequenceDiagram
 ### 4.5 RipplePathFind Migration Design
 
 Current pattern:
+
 ```cpp
 // Continuation callback
 auto callback = [&context]() {
@@ -707,6 +719,7 @@ if (request) {
 ```
 
 Target pattern:
+
 ```cpp
 // Start async work, suspend via co_await
 jvResult = makeLegacyPathRequest(request, /* awaiter-based callback */, ...);
@@ -989,6 +1002,7 @@ gantt
 #### Milestone 1: New Coroutine Primitives (PR #1)
 
 **Deliverables**:
+
 - `CoroTask<T>` with `promise_type`, `FinalAwaiter`
 - `CoroTask<void>` specialization
 - `JobQueueAwaiter` for scheduling on JobQueue
@@ -997,6 +1011,7 @@ gantt
 - Unit test suite: `CoroTask_test.cpp`
 
 **Acceptance Criteria**:
+
 - All new unit tests pass
 - Existing `--unittest` suite passes (no regressions from new code)
 - ASAN + TSAN clean on new tests
@@ -1005,32 +1020,37 @@ gantt
 #### Milestone 2: Entry Point Migration (PR #2)
 
 **Deliverables**:
+
 - `ServerHandler::onRequest()` uses `postCoroTask()`
 - `ServerHandler::onWSMessage()` uses `postCoroTask()`
 - `GRPCServer::CallData::process()` uses `postCoroTask()`
 - `RPC::Context` updated to carry new coroutine type
 - `processSession`/`processRequest` signatures updated
 
 **Acceptance Criteria**:
+
 - HTTP, WebSocket, and gRPC RPC requests work end-to-end
 - Full `--unittest` suite passes
 - Manual smoke test: `ripple_path_find` via HTTP/WS
 
 #### Milestone 3: Handler Migration (PR #3)
 
 **Deliverables**:
+
 - `RipplePathFind` uses `co_await` instead of `yield()/post()`
 - Path_test and AMMTest updated
 - Coroutine_test and JobQueue_test updated for new API
 
 **Acceptance Criteria**:
+
 - Path-finding suspension/continuation works correctly
 - All `--unittest` tests pass
 - Shutdown-during-pathfind scenario tested
 
 #### Milestone 4: Cleanup & Validation (PR #4)
 
 **Deliverables**:
+
 - Old `Coro` class and `Coro.ipp` removed
 - `postCoro()` removed from `JobQueue`
 - `Boost::coroutine` removed from CMake
@@ -1039,6 +1059,7 @@ gantt
 - Sanitizer test results documented
 
 **Acceptance Criteria**:
+
 - Build succeeds without Boost.Coroutine
 - Full `--unittest` suite passes
 - Memory per coroutine ≤ 10KB (down from 1MB)
@@ -1188,13 +1209,15 @@ develop
 ```
 
 **Workflow**:
+
 1. Create sub-branch from `pratik/Switch-to-std-coroutines` for each milestone
 2. Develop and test on the sub-branch
 3. Create PR from sub-branch → `pratik/Switch-to-std-coroutines`
 4. After review + merge, start next milestone sub-branch from the updated feature branch
 5. Final PR from `pratik/Switch-to-std-coroutines` → `develop`
 
 **Rules**:
+
 - Never push directly to the main feature branch — always via sub-branch PR
 - Each sub-branch must pass `--unittest` and sanitizers before PR
 - Sub-branch names follow the pattern: `pratik/std-coro/<descriptive-action>` (e.g., `add-coroutine-primitives`, `migrate-entry-points`)

include/xrpl/core/CoroTask.h

@@ -90,8 +90,7 @@ class CoroTask<void>
             handle_.destroy();
     }
 
-    CoroTask(CoroTask&& other) noexcept
-        : handle_(std::exchange(other.handle_, {}))
+    CoroTask(CoroTask&& other) noexcept : handle_(std::exchange(other.handle_, {}))
     {
     }
 
@@ -229,8 +228,7 @@ class CoroTask
             handle_.destroy();
     }
 
-    CoroTask(CoroTask&& other) noexcept
-        : handle_(std::exchange(other.handle_, {}))
+    CoroTask(CoroTask&& other) noexcept : handle_(std::exchange(other.handle_, {}))
     {
     }
 

include/xrpl/core/JobQueue.h

@@ -2,15 +2,14 @@
 
 #include <xrpl/basics/LocalValue.h>
 #include <xrpl/core/ClosureCounter.h>
+#include <xrpl/core/CoroTask.h>
 #include <xrpl/core/JobTypeData.h>
 #include <xrpl/core/JobTypes.h>
 #include <xrpl/core/detail/Workers.h>
 #include <xrpl/json/json_value.h>
 
 #include <boost/coroutine/all.hpp>
 
-#include <xrpl/core/CoroTask.h>
-
 #include <coroutine>
 #include <set>
 
@@ -146,11 +145,7 @@ class JobQueue : private Workers::Callback
         };
 
         // Private: Used in the implementation of postCoroTask
-        CoroTaskRunner(
-            create_t,
-            JobQueue&,
-            JobType,
-            std::string const&);
+        CoroTaskRunner(create_t, JobQueue&, JobType, std::string const&);
 
         // Not copy-constructible or assignable
         CoroTaskRunner(CoroTaskRunner const&) = delete;
@@ -512,8 +507,7 @@ template <class F>
 std::shared_ptr<JobQueue::CoroTaskRunner>
 JobQueue::postCoroTask(JobType t, std::string const& name, F&& f)
 {
-    auto runner = std::make_shared<CoroTaskRunner>(
-        CoroTaskRunner::create_t{}, *this, t, name);
+    auto runner = std::make_shared<CoroTaskRunner>(CoroTaskRunner::create_t{}, *this, t, name);
     runner->init(std::forward<F>(f));
 
     // Account for the initial suspension (lazy start).

src/test/core/CoroTask_test.cpp

@@ -55,9 +55,7 @@ class CoroTask_test : public beast::unit_test::suite
 
         gate g;
         auto runner = env.app().getJobQueue().postCoroTask(
-            jtCLIENT,
-            "CoroTaskTest",
-            [&](auto) -> CoroTask<void> {
+            jtCLIENT, "CoroTaskTest", [&](auto) -> CoroTask<void> {
                 g.signal();
                 co_return;
             });
@@ -85,9 +83,7 @@ class CoroTask_test : public beast::unit_test::suite
         gate g1, g2;
         std::shared_ptr<JobQueue::CoroTaskRunner> r;
         auto runner = env.app().getJobQueue().postCoroTask(
-            jtCLIENT,
-            "CoroTaskTest",
-            [&](auto runner) -> CoroTask<void> {
+            jtCLIENT, "CoroTaskTest", [&](auto runner) -> CoroTask<void> {
                 r = runner;
                 g1.signal();
                 co_await runner->suspend();
@@ -119,9 +115,7 @@ class CoroTask_test : public beast::unit_test::suite
 
         gate g;
         env.app().getJobQueue().postCoroTask(
-            jtCLIENT,
-            "CoroTaskTest",
-            [&](auto runner) -> CoroTask<void> {
+            jtCLIENT, "CoroTaskTest", [&](auto runner) -> CoroTask<void> {
                 runner->post();
                 co_await runner->suspend();
                 g.signal();
@@ -147,9 +141,7 @@ class CoroTask_test : public beast::unit_test::suite
         gate g;
         int step = 0;
         env.app().getJobQueue().postCoroTask(
-            jtCLIENT,
-            "CoroTaskTest",
-            [&](auto runner) -> CoroTask<void> {
+            jtCLIENT, "CoroTaskTest", [&](auto runner) -> CoroTask<void> {
                 step = 1;
                 co_await JobQueueAwaiter{runner};
                 step = 2;
@@ -193,23 +185,20 @@ class CoroTask_test : public beast::unit_test::suite
 
         for (int i = 0; i < N; ++i)
         {
-            jq.postCoroTask(
-                jtCLIENT,
-                "CoroTaskTest",
-                [&, id = i](auto runner) -> CoroTask<void> {
-                    a[id] = runner;
-                    g.signal();
-                    co_await runner->suspend();
-
-                    this->BEAST_EXPECT(*lv == -1);
-                    *lv = id;
-                    this->BEAST_EXPECT(*lv == id);
-                    g.signal();
-                    co_await runner->suspend();
-
-                    this->BEAST_EXPECT(*lv == id);
-                    co_return;
-                });
+            jq.postCoroTask(jtCLIENT, "CoroTaskTest", [&, id = i](auto runner) -> CoroTask<void> {
+                a[id] = runner;
+                g.signal();
+                co_await runner->suspend();
+
+                this->BEAST_EXPECT(*lv == -1);
+                *lv = id;
+                this->BEAST_EXPECT(*lv == id);
+                g.signal();
+                co_await runner->suspend();
+
+                this->BEAST_EXPECT(*lv == id);
+                co_return;
+            });
             BEAST_EXPECT(g.wait_for(5s));
             a[i]->join();
         }
@@ -249,9 +238,7 @@ class CoroTask_test : public beast::unit_test::suite
 
         gate g;
         auto runner = env.app().getJobQueue().postCoroTask(
-            jtCLIENT,
-            "CoroTaskTest",
-            [&](auto) -> CoroTask<void> {
+            jtCLIENT, "CoroTaskTest", [&](auto) -> CoroTask<void> {
                 g.signal();
                 throw std::runtime_error("test exception");
                 co_return;
@@ -282,9 +269,7 @@ class CoroTask_test : public beast::unit_test::suite
         int counter = 0;
         std::shared_ptr<JobQueue::CoroTaskRunner> r;
         auto runner = env.app().getJobQueue().postCoroTask(
-            jtCLIENT,
-            "CoroTaskTest",
-            [&](auto runner) -> CoroTask<void> {
+            jtCLIENT, "CoroTaskTest", [&](auto runner) -> CoroTask<void> {
                 r = runner;
                 ++counter;
                 g.signal();
@@ -332,9 +317,7 @@ class CoroTask_test : public beast::unit_test::suite
         env.app().getJobQueue().stop();
 
         auto runner = env.app().getJobQueue().postCoroTask(
-            jtCLIENT,
-            "CoroTaskTest",
-            [&](auto) -> CoroTask<void> { co_return; });
+            jtCLIENT, "CoroTaskTest", [&](auto) -> CoroTask<void> { co_return; });
         BEAST_EXPECT(!runner);
     }
 

src/xrpld/rpc/ServerHandler.h

@@ -169,9 +169,7 @@ class ServerHandler
 
 private:
     Json::Value
-    processSession(
-        std::shared_ptr<WSSession> const& session,
-        Json::Value const& jv);
+    processSession(std::shared_ptr<WSSession> const& session, Json::Value const& jv);
 
     void
     processSession(std::shared_ptr<Session> const&);

src/xrpld/rpc/detail/ServerHandler.cpp

@@ -12,9 +12,9 @@
 #include <xrpl/basics/base64.h>
 #include <xrpl/basics/contract.h>
 #include <xrpl/basics/make_SSLContext.h>
-#include <xrpl/core/CoroTask.h>
 #include <xrpl/beast/net/IPAddressConversion.h>
 #include <xrpl/beast/rfc2616.h>
+#include <xrpl/core/CoroTask.h>
 #include <xrpl/core/JobQueue.h>
 #include <xrpl/json/json_reader.h>
 #include <xrpl/json/to_string.h>
@@ -376,9 +376,7 @@ logDuration(Json::Value const& request, T const& duration, beast::Journal& journ
 }
 
 Json::Value
-ServerHandler::processSession(
-    std::shared_ptr<WSSession> const& session,
-    Json::Value const& jv)
+ServerHandler::processSession(std::shared_ptr<WSSession> const& session, Json::Value const& jv)
 {
     auto is = std::static_pointer_cast<WSInfoSub>(session->appDefined);
     if (is->getConsumer().disconnect(m_journal))
@@ -516,8 +514,7 @@ ServerHandler::processSession(
 }
 
 void
-ServerHandler::processSession(
-    std::shared_ptr<Session> const& session)
+ServerHandler::processSession(std::shared_ptr<Session> const& session)
 {
     processRequest(
         session->port(),