clang-format tweaks

ericniebler · ericniebler · commit e5dbe49a5257 · 2025-08-04T10:37:27.000-07:00
diff --git a/.clang-format b/.clang-format
@@ -117,7 +117,7 @@ RemoveBracesLLVM: false
 ReflowComments: false
 RequiresClausePosition: OwnLine
 IndentRequiresClause: true
-SeparateDefinitionBlocks: Always
+SeparateDefinitionBlocks: Leave
 ShortNamespaceLines: 0
 SortIncludes: Never
 SortUsingDeclarations: false
diff --git a/examples/nvexec/maxwell/common.cuh b/examples/nvexec/maxwell/common.cuh
@@ -134,7 +134,6 @@ struct grid_t {
 constexpr float C0 = 299792458.0f; // Speed of light [metres per second]
 
 STDEXEC_ATTRIBUTE(host, device)
-
 inline auto
   is_circle_part(float x, float y, float object_x, float object_y, float object_size) -> bool {
   const float os2 = object_size * object_size;
@@ -194,25 +193,21 @@ inline auto grid_initializer(float dt, fields_accessor accessor) -> grid_initial
 }
 
 STDEXEC_ATTRIBUTE(host, device)
-
 inline auto right_nid(std::size_t cell_id, std::size_t col, std::size_t N) -> std::size_t {
   return col == N - 1 ? cell_id - (N - 1) : cell_id + 1;
 }
 
 STDEXEC_ATTRIBUTE(host, device)
-
 inline auto left_nid(std::size_t cell_id, std::size_t col, std::size_t N) -> std::size_t {
   return col == 0 ? cell_id + N - 1 : cell_id - 1;
 }
 
 STDEXEC_ATTRIBUTE(host, device)
-
 inline auto bottom_nid(std::size_t cell_id, std::size_t row, std::size_t N) -> std::size_t {
   return row == 0 ? cell_id + N * (N - 1) : cell_id - N;
 }
 
 STDEXEC_ATTRIBUTE(host, device)
-
 inline auto top_nid(std::size_t cell_id, std::size_t row, std::size_t N) -> std::size_t {
   return row == N - 1 ? cell_id - N * (N - 1) : cell_id + N;
 }
@@ -247,13 +242,11 @@ struct e_field_calculator_t {
   std::size_t source_position;
 
   STDEXEC_ATTRIBUTE(nodiscard, host, device)
-
   auto gaussian_pulse(float t, float t_0, float tau) const -> float {
     return static_cast<float>(exp(-(((t - t_0) / tau) * (t - t_0) / tau)));
   }
 
   STDEXEC_ATTRIBUTE(nodiscard, host, device)
-
   auto calculate_source(float t, float frequency) const -> float {
     const float tau = 0.5f / frequency;
     const float t_0 = 6.0f * tau;
diff --git a/examples/nvexec/maxwell/snr.cuh b/examples/nvexec/maxwell/snr.cuh
@@ -167,8 +167,7 @@ namespace nvexec::_strm::repeat_n {
     void start() & noexcept {
       if (this->stream_provider_.status_ != cudaSuccess) {
         // Couldn't allocate memory for operation state, complete with error
-        this->propagate_completion_signal(
-          ex::set_error, std::move(this->stream_provider_.status_));
+        this->propagate_completion_signal(ex::set_error, std::move(this->stream_provider_.status_));
       } else {
         if (n_) {
           ex::start(*pred_op_state_);
@@ -181,8 +180,7 @@ namespace nvexec::_strm::repeat_n {
     operation_state_t(PredSender&& pred_sender, Closure closure, Receiver&& rcvr, std::size_t n)
       : operation_state_base_t<ReceiverId>(
           static_cast<Receiver&&>(rcvr),
-          ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(pred_sender))
-            .context_state_)
+          ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(pred_sender)).context_state_)
       , pred_sender_{static_cast<PredSender&&>(pred_sender)}
       , closure_(closure)
       , n_(n) {
diff --git a/include/exec/fork_join.hpp b/include/exec/fork_join.hpp
@@ -71,7 +71,6 @@ namespace exec {
     template <class Domain>
     struct _env_t {
       STDEXEC_ATTRIBUTE(always_inline, host, device)
-
       static constexpr auto query(stdexec::get_domain_t) noexcept -> Domain {
         return {};
       }
@@ -144,7 +143,6 @@ namespace exec {
       using _cache_sndr_t = fork_join_t::_cache_sndr_t<_variant_t<_child_completions_t>, _domain_t>;
 
       STDEXEC_ATTRIBUTE(host, device)
-
       explicit _opstate_t(Sndr&& sndr, Closures&& closures, Rcvr rcvr) noexcept
         : _rcvr_(static_cast<Rcvr&&>(rcvr))
         , _fork_opstate_(
@@ -206,7 +204,6 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(nodiscard, host, device)
-
       constexpr auto get_env() const noexcept -> stdexec::__fwd_env_t<stdexec::env_of_t<Rcvr>> {
         return stdexec::__env::__fwd_fn{}(stdexec::get_env(_rcvr_));
       }
@@ -294,7 +291,6 @@ namespace exec {
     }
 
     STDEXEC_ATTRIBUTE(host, device)
-
     constexpr auto get_env() const noexcept -> stdexec::__fwd_env_t<stdexec::env_of_t<Sndr>> {
       return stdexec::__env::__fwd_fn{}(stdexec::get_env(sndr_));
     }
diff --git a/include/exec/inline_scheduler.hpp b/include/exec/inline_scheduler.hpp
@@ -20,5 +20,6 @@
 namespace exec {
   // A simple scheduler that executes its continuation inline, on the
   // thread of the caller of start().
-  using inline_scheduler [[deprecated("Use stdexec::inline_scheduler instead")]] = stdexec::inline_scheduler;
+  using inline_scheduler
+    [[deprecated("Use stdexec::inline_scheduler instead")]] = stdexec::inline_scheduler;
 } // namespace exec
diff --git a/include/exec/into_tuple.hpp b/include/exec/into_tuple.hpp
@@ -103,7 +103,6 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-
       constexpr auto operator()() const noexcept -> __binder_back<into_tuple_t> {
         return {{}, {}, {}};
       }
diff --git a/include/exec/materialize.hpp b/include/exec/materialize.hpp
@@ -121,7 +121,6 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-
       auto operator()() const noexcept -> __binder_back<__materialize_t> {
         return {{}, {}, {}};
       }
@@ -230,7 +229,6 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-
       auto operator()() const noexcept -> __binder_back<__dematerialize_t> {
         return {{}, {}, {}};
       }
diff --git a/include/exec/repeat_effect_until.hpp b/include/exec/repeat_effect_until.hpp
@@ -78,7 +78,7 @@ namespace exec {
       using __child_t = __decay_t<__data_of<_Sender>>;
       using __receiver_t = stdexec::__t<__receiver<__id<_Sender>, __id<_Receiver>>>;
       using __child_on_sched_sender_t =
-        __result_of<exec::sequence, schedule_result_t<trampoline_scheduler&>, __child_t &>;
+        __result_of<exec::sequence, schedule_result_t<trampoline_scheduler &>, __child_t &>;
       using __child_op_t = stdexec::connect_result_t<__child_on_sched_sender_t, __receiver_t>;
 
       __child_t __child_;
@@ -203,7 +203,6 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-
       constexpr auto operator()() const -> __binder_back<repeat_effect_until_t> {
         return {{}, {}, {}};
       }
@@ -234,7 +233,6 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-
       constexpr auto operator()() const -> __binder_back<repeat_effect_t> {
         return {{}, {}, {}};
       }
diff --git a/include/exec/repeat_n.hpp b/include/exec/repeat_n.hpp
@@ -104,7 +104,7 @@ namespace exec {
       using __child_t = decltype(__child_count_pair_t::__child_);
       using __receiver_t = stdexec::__t<__receiver<__id<_Sender>, __id<_Receiver>>>;
       using __child_on_sched_sender_t =
-        __result_of<exec::sequence, schedule_result_t<trampoline_scheduler&>, __child_t &>;
+        __result_of<exec::sequence, schedule_result_t<trampoline_scheduler &>, __child_t &>;
       using __child_op_t = stdexec::connect_result_t<__child_on_sched_sender_t, __receiver_t>;
 
       __child_count_pair<__child_t> __pair_;
@@ -230,7 +230,6 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-
       constexpr auto
         operator()(std::size_t __count) const -> __binder_back<repeat_n_t, std::size_t> {
         return {{__count}, {}, {}};
diff --git a/include/exec/sequence/ignore_all_values.hpp b/include/exec/sequence/ignore_all_values.hpp
@@ -294,7 +294,6 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-
       constexpr auto operator()() const noexcept -> __binder_back<ignore_all_values_t> {
         return {{}, {}, {}};
       }
diff --git a/include/exec/task.hpp b/include/exec/task.hpp
@@ -335,7 +335,8 @@ namespace exec {
       }
 
      private:
-      using __scheduler_t = __query_result_or_t<get_scheduler_t, _Context, stdexec::inline_scheduler>;
+      using __scheduler_t =
+        __query_result_or_t<get_scheduler_t, _Context, stdexec::inline_scheduler>;
 
       struct __final_awaitable {
         static constexpr auto await_ready() noexcept -> bool {
diff --git a/include/nvexec/detail/queue.cuh b/include/nvexec/detail/queue.cuh
@@ -44,7 +44,6 @@ namespace nvexec::_strm::queue {
     task_base_t** tail_;
 
     STDEXEC_ATTRIBUTE(host, device)
-
     void operator()(task_base_t* task) {
       atom_task_ref tail_ref(*tail_);
       task_base_t* old_tail = tail_ref.load(::cuda::memory_order_acquire);
diff --git a/include/nvexec/detail/variant.cuh b/include/nvexec/detail/variant.cuh
@@ -175,7 +175,6 @@ namespace nvexec {
     }
 
     STDEXEC_ATTRIBUTE(host, device)
-
     variant_t()
       requires std::default_initializable<front_t>
     {
diff --git a/include/nvexec/multi_gpu_context.cuh b/include/nvexec/multi_gpu_context.cuh
@@ -99,7 +99,6 @@ namespace nvexec {
           stdexec::completion_signatures<set_value_t(), set_error_t(cudaError_t)>;
 
         STDEXEC_ATTRIBUTE(host, device)
-
         explicit sender_t(int num_devices, context_state_t context_state) noexcept
           : env_{.num_devices_ = num_devices, .context_state_ = context_state} {
         }
diff --git a/include/nvexec/nvtx.cuh b/include/nvexec/nvtx.cuh
@@ -139,7 +139,6 @@ namespace nvexec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-
       auto operator()(std::string name) const -> stdexec::__binder_back<push_t, std::string> {
         return {{std::move(name)}, {}, {}};
       }
@@ -152,7 +151,6 @@ namespace nvexec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-
       auto operator()() const noexcept -> stdexec::__binder_back<pop_t> {
         return {{}, {}, {}};
       }
diff --git a/include/nvexec/stream_context.cuh b/include/nvexec/stream_context.cuh
@@ -44,13 +44,11 @@ namespace nvexec {
   namespace _strm {
     struct stream_scheduler_env {
       STDEXEC_ATTRIBUTE(nodiscard)
-
       static auto query(get_forward_progress_guarantee_t) noexcept -> forward_progress_guarantee {
         return forward_progress_guarantee::weakly_parallel;
       }
 
       STDEXEC_ATTRIBUTE(nodiscard)
-
       constexpr auto query(get_domain_t) const noexcept -> stream_domain {
         return {};
       }
@@ -108,7 +106,6 @@ namespace nvexec {
           stdexec::completion_signatures<set_value_t(), set_error_t(cudaError_t)>;
 
         STDEXEC_ATTRIBUTE(host, device)
-
         explicit sender_t(context_state_t context_state) noexcept
           : env_{context_state} {
         }
@@ -131,7 +128,6 @@ namespace nvexec {
           context_state_t context_state_;
 
           STDEXEC_ATTRIBUTE(nodiscard)
-
           auto query(get_completion_scheduler_t<set_value_t>) const noexcept -> stream_scheduler {
             return stream_scheduler{context_state_};
           }
diff --git a/include/stdexec/__detail/__config.hpp b/include/stdexec/__detail/__config.hpp
@@ -583,7 +583,6 @@ namespace stdexec {
   };
 
   STDEXEC_ATTRIBUTE(noreturn, host, device)
-
   inline void __terminate() noexcept {
     STDEXEC_IF_HOST(::exit(-1))
     STDEXEC_IF_DEVICE(__trap())
diff --git a/include/stdexec/__detail/__debug.hpp b/include/stdexec/__detail/__debug.hpp
@@ -90,7 +90,6 @@ namespace stdexec {
       }
 
       STDEXEC_ATTRIBUTE(host, device)
-
       void set_stopped() noexcept
         requires __one_of<set_stopped_t (*)(), _Sigs...>
       {
diff --git a/include/stdexec/__detail/__ensure_started.hpp b/include/stdexec/__detail/__ensure_started.hpp
@@ -53,7 +53,6 @@ namespace stdexec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-
       auto operator()() const noexcept -> __binder_back<ensure_started_t> {
         return {{}, {}, {}};
       }
diff --git a/include/stdexec/__detail/__env.hpp b/include/stdexec/__detail/__env.hpp
@@ -425,7 +425,6 @@ namespace stdexec {
       using __id = cprop;
 
       STDEXEC_ATTRIBUTE(nodiscard)
-
       static constexpr auto query(_Query) noexcept {
         return _Value;
       }
diff --git a/include/stdexec/__detail/__into_variant.hpp b/include/stdexec/__detail/__into_variant.hpp
@@ -63,7 +63,6 @@ namespace stdexec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-
       auto operator()() const noexcept -> __binder_back<into_variant_t> {
         return {{}, {}, {}};
       }
diff --git a/include/stdexec/__detail/__receiver_adaptor.hpp b/include/stdexec/__detail/__receiver_adaptor.hpp
@@ -56,7 +56,6 @@ namespace stdexec {
       }
 
       STDEXEC_ATTRIBUTE(host, device, always_inline)
-
       auto base() const & noexcept -> const _Base& {
         return __base_;
       }
diff --git a/include/stdexec/__detail/__receiver_ref.hpp b/include/stdexec/__detail/__receiver_ref.hpp
@@ -29,7 +29,6 @@ namespace stdexec {
     using receiver_concept = receiver_t;
 
     STDEXEC_ATTRIBUTE(host, device)
-
     explicit constexpr __rcvr_ref(_Rcvr& __rcvr) noexcept
       : __rcvr_{std::addressof(__rcvr)} {
     }
diff --git a/include/stdexec/__detail/__receivers.hpp b/include/stdexec/__detail/__receivers.hpp
@@ -148,7 +148,9 @@ namespace stdexec {
   namespace __detail {
     template <class _Receiver>
     concept __enable_receiver =
-      (STDEXEC_WHEN(STDEXEC_EDG(), requires { typename _Receiver::receiver_concept; } &&)
+      (STDEXEC_WHEN(
+        STDEXEC_EDG(),
+        requires { typename _Receiver::receiver_concept; } &&)
          derived_from<typename _Receiver::receiver_concept, receiver_t>)
       || requires { typename _Receiver::is_receiver; } // back-compat, NOT TO SPEC
       || STDEXEC_IS_BASE_OF(receiver_t, _Receiver);    // NOT TO SPEC, for receiver_adaptor
diff --git a/include/stdexec/__detail/__sender_adaptor_closure.hpp b/include/stdexec/__detail/__sender_adaptor_closure.hpp
@@ -94,7 +94,6 @@ namespace stdexec {
         _Sender& __sndr_;
 
         STDEXEC_ATTRIBUTE(host, device, always_inline)
-
         auto operator()(_As&... __as) const noexcept(__nothrow_callable<_Fun, _Sender, _As...>)
           -> __call_result_t<_Fun, _Sender, _As...> {
           return static_cast<_Fun&&>(
@@ -108,7 +107,6 @@ namespace stdexec {
         _Sender& __sndr_;
 
         STDEXEC_ATTRIBUTE(host, device, always_inline)
-
         auto operator()(const _As&... __as) const
           noexcept(__nothrow_callable<const _Fun&, _Sender, const _As&...>)
             -> __call_result_t<const _Fun&, _Sender, const _As&...> {
diff --git a/include/stdexec/__detail/__split.hpp b/include/stdexec/__detail/__split.hpp
@@ -46,7 +46,6 @@ namespace stdexec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-
       auto operator()() const noexcept -> __binder_back<split_t> {
         return {{}, {}, {}};
       }
diff --git a/include/stdexec/__detail/__starts_on.hpp b/include/stdexec/__detail/__starts_on.hpp
@@ -36,7 +36,6 @@ namespace stdexec {
       _Ty __val_;
 
       STDEXEC_ATTRIBUTE(always_inline)
-
       constexpr auto operator()() noexcept(__nothrow_constructible_from<_Ty, _Ty>) -> _Ty {
         return static_cast<_Ty&&>(__val_);
       }
diff --git a/include/stdexec/__detail/__stopped_as_optional.hpp b/include/stdexec/__detail/__stopped_as_optional.hpp
@@ -44,7 +44,6 @@ namespace stdexec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-
       auto operator()() const noexcept -> __binder_back<stopped_as_optional_t> {
         return {{}, {}, {}};
       }
diff --git a/include/stdexec/__detail/__variant.hpp b/include/stdexec/__detail/__variant.hpp
@@ -48,7 +48,6 @@ namespace stdexec {
 
   namespace __var {
     STDEXEC_ATTRIBUTE(host, device)
-
     inline auto __mk_index_guard(std::size_t &__index, std::size_t __new) noexcept {
       __index = __new;
       return __scope_guard{[&__index]() noexcept { __index = __variant_npos; }};

Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,6 @@ namespace exec {`
`71`	`71`	`template <class Domain>`
`72`	`72`	`struct _env_t {`
`73`	`73`	`STDEXEC_ATTRIBUTE(always_inline, host, device)`
`74`		`-`
`75`	`74`	`static constexpr auto query(stdexec::get_domain_t) noexcept -> Domain {`
`76`	`75`	`return {};`
`77`	`76`	`}`
`@@ -144,7 +143,6 @@ namespace exec {`
`144`	`143`	`using _cache_sndr_t = fork_join_t::_cache_sndr_t<_variant_t<_child_completions_t>, _domain_t>;`
`145`	`144`
`146`	`145`	`STDEXEC_ATTRIBUTE(host, device)`
`147`		`-`
`148`	`146`	`explicit _opstate_t(Sndr&& sndr, Closures&& closures, Rcvr rcvr) noexcept`
`149`	`147`	`: _rcvr_(static_cast<Rcvr&&>(rcvr))`
`150`	`148`	`, _fork_opstate_(`
`@@ -206,7 +204,6 @@ namespace exec {`
`206`	`204`	`}`
`207`	`205`
`208`	`206`	`STDEXEC_ATTRIBUTE(nodiscard, host, device)`
`209`		`-`
`210`	`207`	`constexpr auto get_env() const noexcept -> stdexec::__fwd_env_t<stdexec::env_of_t<Rcvr>> {`
`211`	`208`	`return stdexec::__env::__fwd_fn{}(stdexec::get_env(_rcvr_));`
`212`	`209`	`}`
`@@ -294,7 +291,6 @@ namespace exec {`
`294`	`291`	`}`
`295`	`292`
`296`	`293`	`STDEXEC_ATTRIBUTE(host, device)`
`297`		`-`
`298`	`294`	`constexpr auto get_env() const noexcept -> stdexec::__fwd_env_t<stdexec::env_of_t<Sndr>> {`
`299`	`295`	`return stdexec::__env::__fwd_fn{}(stdexec::get_env(sndr_));`
`300`	`296`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,6 @@ namespace exec {`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`STDEXEC_ATTRIBUTE(always_inline)`
`106`		`-`
`107`	`106`	`constexpr auto operator()() const noexcept -> __binder_back<into_tuple_t> {`
`108`	`107`	`return {{}, {}, {}};`
`109`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,6 @@ namespace exec {`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`STDEXEC_ATTRIBUTE(always_inline)`
`124`		`-`
`125`	`124`	`auto operator()() const noexcept -> __binder_back<__materialize_t> {`
`126`	`125`	`return {{}, {}, {}};`
`127`	`126`	`}`
`@@ -230,7 +229,6 @@ namespace exec {`
`230`	`229`	`}`
`231`	`230`
`232`	`231`	`STDEXEC_ATTRIBUTE(always_inline)`
`233`		`-`
`234`	`232`	`auto operator()() const noexcept -> __binder_back<__dematerialize_t> {`
`235`	`233`	`return {{}, {}, {}};`
`236`	`234`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ namespace exec {`
`78`	`78`	`using __child_t = __decay_t<__data_of<_Sender>>;`
`79`	`79`	`using __receiver_t = stdexec::__t<__receiver<__id<_Sender>, __id<_Receiver>>>;`
`80`	`80`	`using __child_on_sched_sender_t =`
`81`		`- __result_of<exec::sequence, schedule_result_t<trampoline_scheduler&>, __child_t &>;`
	`81`	`+ __result_of<exec::sequence, schedule_result_t<trampoline_scheduler &>, __child_t &>;`
`82`	`82`	`using __child_op_t = stdexec::connect_result_t<__child_on_sched_sender_t, __receiver_t>;`
`83`	`83`
`84`	`84`	`__child_t __child_;`
`@@ -203,7 +203,6 @@ namespace exec {`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`STDEXEC_ATTRIBUTE(always_inline)`
`206`		`-`
`207`	`206`	`constexpr auto operator()() const -> __binder_back<repeat_effect_until_t> {`
`208`	`207`	`return {{}, {}, {}};`
`209`	`208`	`}`
`@@ -234,7 +233,6 @@ namespace exec {`
`234`	`233`	`}`
`235`	`234`
`236`	`235`	`STDEXEC_ATTRIBUTE(always_inline)`
`237`		`-`
`238`	`236`	`constexpr auto operator()() const -> __binder_back<repeat_effect_t> {`
`239`	`237`	`return {{}, {}, {}};`
`240`	`238`	`}`
Original file line number	Diff line number	Diff line change
`@@ -294,7 +294,6 @@ namespace exec {`
`294`	`294`	`}`
`295`	`295`
`296`	`296`	`STDEXEC_ATTRIBUTE(always_inline)`
`297`		`-`
`298`	`297`	`constexpr auto operator()() const noexcept -> __binder_back<ignore_all_values_t> {`
`299`	`298`	`return {{}, {}, {}};`
`300`	`299`	`}`