fix: clang format

src/audio_core/in/audio_in.cpp

@@ -8,8 +8,8 @@
 namespace AudioCore::AudioIn {
 
 In::In(Core::System& system_, Manager& manager_, Kernel::KEvent* event_, size_t session_id_)
-    : manager{manager_}, parent_mutex{manager.mutex}, event{event_},
+    : manager{manager_}, parent_mutex{manager.mutex}, event{event_}, system{system_, event,
-      system{system_, event, session_id_} {}
+                                                                            session_id_} {}
 
 void In::Free() {
     std::scoped_lock l{parent_mutex};

src/audio_core/in/audio_in_system.cpp

@@ -14,8 +14,8 @@
 namespace AudioCore::AudioIn {
 
 System::System(Core::System& system_, Kernel::KEvent* event_, const size_t session_id_)
-    : system{system_}, buffer_event{event_}, session_id{session_id_},
+    : system{system_}, buffer_event{event_},
-      session{std::make_unique<DeviceSession>(system_)} {}
+      session_id{session_id_}, session{std::make_unique<DeviceSession>(system_)} {}
 
 System::~System() {
     Finalize();

src/audio_core/out/audio_out.cpp

@@ -8,8 +8,8 @@
 namespace AudioCore::AudioOut {
 
 Out::Out(Core::System& system_, Manager& manager_, Kernel::KEvent* event_, size_t session_id_)
-    : manager{manager_}, parent_mutex{manager.mutex}, event{event_},
+    : manager{manager_}, parent_mutex{manager.mutex}, event{event_}, system{system_, event,
-      system{system_, event, session_id_} {}
+                                                                            session_id_} {}
 
 void Out::Free() {
     std::scoped_lock l{parent_mutex};

src/audio_core/out/audio_out_system.cpp

@@ -14,8 +14,8 @@
 namespace AudioCore::AudioOut {
 
 System::System(Core::System& system_, Kernel::KEvent* event_, size_t session_id_)
-    : system{system_}, buffer_event{event_}, session_id{session_id_},
+    : system{system_}, buffer_event{event_},
-      session{std::make_unique<DeviceSession>(system_)} {}
+      session_id{session_id_}, session{std::make_unique<DeviceSession>(system_)} {}
 
 System::~System() {
     Finalize();

src/audio_core/renderer/behavior/info_updater.cpp

@@ -19,9 +19,10 @@ namespace AudioCore::Renderer {
 
 InfoUpdater::InfoUpdater(std::span<const u8> input_, std::span<u8> output_,
                          Kernel::KProcess* process_handle_, BehaviorInfo& behaviour_)
-    : input{input_.data() + sizeof(UpdateDataHeader)}, input_origin{input_},
+    : input{input_.data() + sizeof(UpdateDataHeader)},
-      output{output_.data() + sizeof(UpdateDataHeader)}, output_origin{output_},
+      input_origin{input_}, output{output_.data() + sizeof(UpdateDataHeader)},
-      in_header{reinterpret_cast<const UpdateDataHeader*>(input_origin.data())},
+      output_origin{output_}, in_header{reinterpret_cast<const UpdateDataHeader*>(
+                                  input_origin.data())},
       out_header{reinterpret_cast<UpdateDataHeader*>(output_origin.data())},
       expected_input_size{input_.size()}, expected_output_size{output_.size()},
       process_handle{process_handle_}, behaviour{behaviour_} {

src/audio_core/renderer/memory/pool_mapper.cpp

@@ -13,8 +13,8 @@ PoolMapper::PoolMapper(Kernel::KProcess* process_handle_, bool force_map_)
 
 PoolMapper::PoolMapper(Kernel::KProcess* process_handle_, std::span<MemoryPoolInfo> pool_infos_,
                        u32 pool_count_, bool force_map_)
-    : process_handle{process_handle_}, pool_infos{pool_infos_.data()}, pool_count{pool_count_},
+    : process_handle{process_handle_}, pool_infos{pool_infos_.data()},
-      force_map{force_map_} {}
+      pool_count{pool_count_}, force_map{force_map_} {}
 
 void PoolMapper::ClearUseState(std::span<MemoryPoolInfo> pools, const u32 count) {
     for (u32 i = 0; i < count; i++) {

src/common/address_space.h

@@ -12,7 +12,8 @@
 
 namespace Common {
 template <typename VaType, size_t AddressSpaceBits>
-concept AddressSpaceValid = std::is_unsigned_v<VaType> && sizeof(VaType) * 8 >= AddressSpaceBits;
+concept AddressSpaceValid = std::is_unsigned_v<VaType> && sizeof(VaType) * 8 >=
+AddressSpaceBits;
 
 struct EmptyStruct {};
 

src/common/concepts.h

@@ -18,7 +18,7 @@ template <typename Derived, typename Base>
 concept DerivedFrom = requires {
                           std::is_base_of_v<Base, Derived>;
                           std::is_convertible_v<const volatile Derived*, const volatile Base*>;
-};
+                      };
 
 // TODO: Replace with std::convertible_to when libc++ implements it.
 template <typename From, typename To>

src/common/expected.h

@@ -598,14 +598,14 @@ public:
     template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
               std::enable_if_t<!std::is_convertible_v<G&&, E>>* = nullptr>
     constexpr explicit Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
-        : impl_base{unexpect_t{}, std::move(e.value())},
+        : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
-          ctor_base{detail::default_constructor_tag{}} {}
+                                                             detail::default_constructor_tag{}} {}
 
     template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
               std::enable_if_t<std::is_convertible_v<G&&, E>>* = nullptr>
     constexpr Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
-        : impl_base{unexpect_t{}, std::move(e.value())},
+        : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
-          ctor_base{detail::default_constructor_tag{}} {}
+                                                             detail::default_constructor_tag{}} {}
 
     template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
     constexpr explicit Expected(unexpect_t, Args&&... args)

src/common/intrusive_red_black_tree.h

@@ -238,8 +238,10 @@ public:
 
 template <typename T>
 concept HasRedBlackKeyType = requires {
-    { std::is_same<typename T::RedBlackKeyType, void>::value } -> std::convertible_to<bool>;
+                                 {
-};
+                                     std::is_same<typename T::RedBlackKeyType, void>::value
+                                     } -> std::convertible_to<bool>;
+                             };
 
 namespace impl {
 

src/common/multi_level_page_table.h

@@ -25,12 +25,12 @@ public:
 
     MultiLevelPageTable(MultiLevelPageTable&& other) noexcept
         : address_space_bits{std::exchange(other.address_space_bits, 0)},
-          first_level_bits{std::exchange(other.first_level_bits, 0)},
+          first_level_bits{std::exchange(other.first_level_bits, 0)}, page_bits{std::exchange(
-          page_bits{std::exchange(other.page_bits, 0)},
+                                                                          other.page_bits, 0)},
           first_level_shift{std::exchange(other.first_level_shift, 0)},
           first_level_chunk_size{std::exchange(other.first_level_chunk_size, 0)},
-          first_level_map{std::move(other.first_level_map)},
+          first_level_map{std::move(other.first_level_map)}, base_ptr{std::exchange(other.base_ptr,
-          base_ptr{std::exchange(other.base_ptr, nullptr)} {}
+                                                                                    nullptr)} {}
 
     MultiLevelPageTable& operator=(MultiLevelPageTable&& other) noexcept {
         address_space_bits = std::exchange(other.address_space_bits, 0);

src/common/polyfill_ranges.h

@@ -20,7 +20,7 @@ template <typename T>
 concept range = requires(T& t) {
                     begin(t);
                     end(t);
-};
+                };
 
 template <typename T>
 concept input_range = range<T>;

src/common/tree.h

@@ -105,7 +105,7 @@ template <typename T>
 concept HasRBEntry = requires(T& t, const T& ct) {
                          { t.GetRBEntry() } -> std::same_as<RBEntry<T>&>;
                          { ct.GetRBEntry() } -> std::same_as<const RBEntry<T>&>;
-};
+                     };
 
 template <typename T>
     requires HasRBEntry<T>

src/common/vector_math.h

@@ -362,9 +362,7 @@ public:
 // _DEFINE_SWIZZLER2 defines a single such function, DEFINE_SWIZZLER2 defines all of them for all
 // component names (x<->r) and permutations (xy<->yx)
 #define _DEFINE_SWIZZLER2(a, b, name)                                                              \
-    [[nodiscard]] constexpr Vec2<T> name() const {                                                 \
+    [[nodiscard]] constexpr Vec2<T> name() const { return Vec2<T>(a, b); }
-        return Vec2<T>(a, b);                                                                      \
-    }
 #define DEFINE_SWIZZLER2(a, b, a2, b2, a3, b3, a4, b4)                                             \
     _DEFINE_SWIZZLER2(a, b, a##b);                                                                 \
     _DEFINE_SWIZZLER2(a, b, a2##b2);                                                               \
@@ -557,9 +555,7 @@ public:
 // DEFINE_SWIZZLER2_COMP2 defines two component functions for all component names (x<->r) and
 // permutations (xy<->yx)
 #define _DEFINE_SWIZZLER2(a, b, name)                                                              \
-    [[nodiscard]] constexpr Vec2<T> name() const {                                                 \
+    [[nodiscard]] constexpr Vec2<T> name() const { return Vec2<T>(a, b); }
-        return Vec2<T>(a, b);                                                                      \
-    }
 #define DEFINE_SWIZZLER2_COMP1(a, a2)                                                              \
     _DEFINE_SWIZZLER2(a, a, a##a);                                                                 \
     _DEFINE_SWIZZLER2(a, a, a2##a2)
@@ -584,9 +580,7 @@ public:
 #undef _DEFINE_SWIZZLER2
 
 #define _DEFINE_SWIZZLER3(a, b, c, name)                                                           \
-    [[nodiscard]] constexpr Vec3<T> name() const {                                                 \
+    [[nodiscard]] constexpr Vec3<T> name() const { return Vec3<T>(a, b, c); }
-        return Vec3<T>(a, b, c);                                                                   \
-    }
 #define DEFINE_SWIZZLER3_COMP1(a, a2)                                                              \
     _DEFINE_SWIZZLER3(a, a, a, a##a##a);                                                           \
     _DEFINE_SWIZZLER3(a, a, a, a2##a2##a2)

src/common/virtual_buffer.h

@@ -33,8 +33,8 @@ public:
     VirtualBuffer& operator=(const VirtualBuffer&) = delete;
 
     VirtualBuffer(VirtualBuffer&& other) noexcept
-        : alloc_size{std::exchange(other.alloc_size, 0)},
+        : alloc_size{std::exchange(other.alloc_size, 0)}, base_ptr{std::exchange(other.base_ptr),
-          base_ptr{std::exchange(other.base_ptr), nullptr} {}
+                                                                   nullptr} {}
 
     VirtualBuffer& operator=(VirtualBuffer&& other) noexcept {
         alloc_size = std::exchange(other.alloc_size, 0);

src/common/x64/native_clock.cpp

@@ -8,8 +8,8 @@
 namespace Common::X64 {
 
 NativeClock::NativeClock(u64 rdtsc_frequency_)
-    : rdtsc_frequency{rdtsc_frequency_},
+    : rdtsc_frequency{rdtsc_frequency_}, ns_rdtsc_factor{GetFixedPoint64Factor(NsRatio::den,
-      ns_rdtsc_factor{GetFixedPoint64Factor(NsRatio::den, rdtsc_frequency)},
+                                                                               rdtsc_frequency)},
       us_rdtsc_factor{GetFixedPoint64Factor(UsRatio::den, rdtsc_frequency)},
       ms_rdtsc_factor{GetFixedPoint64Factor(MsRatio::den, rdtsc_frequency)},
       cntpct_rdtsc_factor{GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency)},

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -16,8 +16,8 @@ using namespace Common::Literals;
 class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
 public:
     explicit DynarmicCallbacks32(ArmDynarmic32& parent, Kernel::KProcess* process)
-        : m_parent{parent}, m_memory(process->GetMemory()), m_process(process),
+        : m_parent{parent}, m_memory(process->GetMemory()),
-          m_debugger_enabled{parent.m_system.DebuggerEnabled()},
+          m_process(process), m_debugger_enabled{parent.m_system.DebuggerEnabled()},
           m_check_memory_access{m_debugger_enabled ||
                                 !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}
 

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -16,8 +16,8 @@ using namespace Common::Literals;
 class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
 public:
     explicit DynarmicCallbacks64(ArmDynarmic64& parent, Kernel::KProcess* process)
-        : m_parent{parent}, m_memory(process->GetMemory()), m_process(process),
+        : m_parent{parent}, m_memory(process->GetMemory()),
-          m_debugger_enabled{parent.m_system.DebuggerEnabled()},
+          m_process(process), m_debugger_enabled{parent.m_system.DebuggerEnabled()},
           m_check_memory_access{m_debugger_enabled ||
                                 !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}
 

src/core/file_sys/card_image.cpp

@@ -29,8 +29,8 @@ constexpr std::array partition_names{
 
 XCI::XCI(VirtualFile file_, u64 program_id, size_t program_index)
     : file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
-      partitions(partition_names.size()), partitions_raw(partition_names.size()),
+      partitions(partition_names.size()),
-      keys{Core::Crypto::KeyManager::Instance()} {
+      partitions_raw(partition_names.size()), keys{Core::Crypto::KeyManager::Instance()} {
     const auto header_status = TryReadHeader();
     if (header_status != Loader::ResultStatus::Success) {
         status = header_status;

src/core/file_sys/fs_path_utility.h

@@ -91,12 +91,8 @@ public:
     }
 
 #define DECLARE_PATH_FLAG_HANDLER(__WHICH__)                                                       \
-    constexpr bool Is##__WHICH__##Allowed() const {                                                \
+    constexpr bool Is##__WHICH__##Allowed() const { return (m_value & __WHICH__##Flag) != 0; }     \
-        return (m_value & __WHICH__##Flag) != 0;                                                   \
+    constexpr void Allow##__WHICH__() { m_value |= __WHICH__##Flag; }
-    }                                                                                              \
-    constexpr void Allow##__WHICH__() {                                                            \
-        m_value |= __WHICH__##Flag;                                                                \
-    }
 
     DECLARE_PATH_FLAG_HANDLER(WindowsPath)
     DECLARE_PATH_FLAG_HANDLER(RelativePath)

src/core/file_sys/submission_package.cpp

@@ -19,9 +19,9 @@
 namespace FileSys {
 
 NSP::NSP(VirtualFile file_, u64 title_id_, std::size_t program_index_)
-    : file(std::move(file_)), expected_program_id(title_id_), program_index(program_index_),
+    : file(std::move(file_)), expected_program_id(title_id_),
-      status{Loader::ResultStatus::Success}, pfs(std::make_shared<PartitionFilesystem>(file)),
+      program_index(program_index_), status{Loader::ResultStatus::Success},
-      keys{Core::Crypto::KeyManager::Instance()} {
+      pfs(std::make_shared<PartitionFilesystem>(file)), keys{Core::Crypto::KeyManager::Instance()} {
     if (pfs->GetStatus() != Loader::ResultStatus::Success) {
         status = pfs->GetStatus();
         return;

src/core/file_sys/xts_archive.cpp

@@ -44,8 +44,8 @@ static bool CalculateHMAC256(Destination* out, const SourceKey* key, std::size_t
 }
 
 NAX::NAX(VirtualFile file_)
-    : header(std::make_unique<NAXHeader>()), file(std::move(file_)),
+    : header(std::make_unique<NAXHeader>()),
-      keys{Core::Crypto::KeyManager::Instance()} {
+      file(std::move(file_)), keys{Core::Crypto::KeyManager::Instance()} {
     std::string path = Common::FS::SanitizePath(file->GetFullPath());
     static const std::regex nax_path_regex("/registered/(000000[0-9A-F]{2})/([0-9A-F]{32})\\.nca",
                                            std::regex_constants::ECMAScript |
@@ -62,8 +62,8 @@ NAX::NAX(VirtualFile file_)
 }
 
 NAX::NAX(VirtualFile file_, std::array<u8, 0x10> nca_id)
-    : header(std::make_unique<NAXHeader>()), file(std::move(file_)),
+    : header(std::make_unique<NAXHeader>()),
-      keys{Core::Crypto::KeyManager::Instance()} {
+      file(std::move(file_)), keys{Core::Crypto::KeyManager::Instance()} {
     Core::Crypto::SHA256Hash hash{};
     mbedtls_sha256_ret(nca_id.data(), nca_id.size(), hash.data(), 0);
     status = Parse(fmt::format("/registered/000000{:02X}/{}.nca", hash[0],

src/core/hle/kernel/k_auto_object.h

@@ -24,9 +24,7 @@ private:
     friend class ::Kernel::KClassTokenGenerator;                                                   \
     static constexpr inline auto ObjectType = ::Kernel::KClassTokenGenerator::ObjectType::CLASS;   \
     static constexpr inline const char* const TypeName = #CLASS;                                   \
-    static constexpr inline ClassTokenType ClassToken() {                                          \
+    static constexpr inline ClassTokenType ClassToken() { return ::Kernel::ClassToken<CLASS>; }    \
-        return ::Kernel::ClassToken<CLASS>;                                                        \
-    }                                                                                              \
                                                                                                    \
 public:                                                                                            \
     SUYU_NON_COPYABLE(CLASS);                                                                      \
@@ -37,15 +35,9 @@ public:
         constexpr ClassTokenType Token = ClassToken();                                             \
         return TypeObj(TypeName, Token);                                                           \
     }                                                                                              \
-    static constexpr const char* GetStaticTypeName() {                                             \
+    static constexpr const char* GetStaticTypeName() { return TypeName; }                          \
-        return TypeName;                                                                           \
+    virtual TypeObj GetTypeObj() ATTRIBUTE { return GetStaticTypeObj(); }                          \
-    }                                                                                              \
+    virtual const char* GetTypeName() ATTRIBUTE { return GetStaticTypeName(); }                    \
-    virtual TypeObj GetTypeObj() ATTRIBUTE {                                                       \
-        return GetStaticTypeObj();                                                                 \
-    }                                                                                              \
-    virtual const char* GetTypeName() ATTRIBUTE {                                                  \
-        return GetStaticTypeName();                                                                \
-    }                                                                                              \
                                                                                                    \
 private:                                                                                           \
     constexpr bool operator!=(const TypeObj& rhs)

src/core/hle/kernel/k_memory_layout.cpp

@@ -128,8 +128,8 @@ KVirtualAddress KMemoryRegionTree::GetRandomAlignedRegion(size_t size, size_t al
 
 KMemoryLayout::KMemoryLayout()
     : m_virtual_tree{m_memory_region_allocator}, m_physical_tree{m_memory_region_allocator},
-      m_virtual_linear_tree{m_memory_region_allocator},
+      m_virtual_linear_tree{m_memory_region_allocator}, m_physical_linear_tree{
-      m_physical_linear_tree{m_memory_region_allocator} {}
+                                                            m_memory_region_allocator} {}
 
 void KMemoryLayout::InitializeLinearMemoryRegionTrees(KPhysicalAddress aligned_linear_phys_start,
                                                       KVirtualAddress linear_virtual_start) {

src/core/hle/kernel/k_priority_queue.h

@@ -17,32 +17,38 @@ namespace Kernel {
 class KThread;
 
 template <typename T>
-concept KPriorityQueueAffinityMask = !std::is_reference_v<T> && requires(T& t) {
+concept KPriorityQueueAffinityMask = !
+std::is_reference_v<T>&& requires(T& t) {
                              { t.GetAffinityMask() } -> Common::ConvertibleTo<u64>;
                              { t.SetAffinityMask(0) };
 
                              { t.GetAffinity(0) } -> std::same_as<bool>;
                              { t.SetAffinity(0, false) };
                              { t.SetAll() };
-};
+                         };
 
 template <typename T>
-concept KPriorityQueueMember = !std::is_reference_v<T> && requires(T& t) {
+concept KPriorityQueueMember = !
+std::is_reference_v<T>&& requires(T& t) {
                              { typename T::QueueEntry() };
                              { (typename T::QueueEntry()).Initialize() };
                              { (typename T::QueueEntry()).SetPrev(std::addressof(t)) };
                              { (typename T::QueueEntry()).SetNext(std::addressof(t)) };
                              { (typename T::QueueEntry()).GetNext() } -> std::same_as<T*>;
                              { (typename T::QueueEntry()).GetPrev() } -> std::same_as<T*>;
-    { t.GetPriorityQueueEntry(0) } -> std::same_as<typename T::QueueEntry&>;
+                             {
+                                 t.GetPriorityQueueEntry(0)
+                                 } -> std::same_as<typename T::QueueEntry&>;
 
                              { t.GetAffinityMask() };
-    { std::remove_cvref_t<decltype(t.GetAffinityMask())>() } -> KPriorityQueueAffinityMask;
+                             {
+                                 std::remove_cvref_t<decltype(t.GetAffinityMask())>()
+                                 } -> KPriorityQueueAffinityMask;
 
                              { t.GetActiveCore() } -> Common::ConvertibleTo<s32>;
                              { t.GetPriority() } -> Common::ConvertibleTo<s32>;
                              { t.IsDummyThread() } -> Common::ConvertibleTo<bool>;
-};
+                         };
 
 template <typename Member, size_t NumCores_, int LowestPriority, int HighestPriority>
     requires KPriorityQueueMember<Member>

src/core/hle/kernel/k_scoped_lock.h

@@ -10,10 +10,11 @@
 namespace Kernel {
 
 template <typename T>
-concept KLockable = !std::is_reference_v<T> && requires(T& t) {
+concept KLockable = !
+std::is_reference_v<T>&& requires(T& t) {
                              { t.Lock() } -> std::same_as<void>;
                              { t.Unlock() } -> std::same_as<void>;
-};
+                         };
 
 template <typename T>
     requires KLockable<T>

src/core/hle/result.h

@@ -458,13 +458,9 @@ constexpr inline Result __TmpCurrentResultReference = ResultSuccess;
         if (true)
 
 #define R_CONVERT(catch_type, convert_type)                                                        \
-    R_CATCH(catch_type) {                                                                          \
+    R_CATCH(catch_type) { R_THROW(static_cast<Result>(convert_type)); }
-        R_THROW(static_cast<Result>(convert_type));                                                \
-    }
 
 #define R_CONVERT_ALL(convert_type)                                                                \
-    R_CATCH_ALL() {                                                                                \
+    R_CATCH_ALL() { R_THROW(static_cast<Result>(convert_type)); }
-        R_THROW(static_cast<Result>(convert_type));                                                \
-    }
 
 #define R_ASSERT(res_expr) ASSERT(R_SUCCEEDED(res_expr))

src/core/hle/service/acc/acc.cpp

@@ -1028,8 +1028,8 @@ void Module::Interface::TrySelectUserWithoutInteraction(HLERequestContext& ctx)
 Module::Interface::Interface(std::shared_ptr<Module> module_,
                              std::shared_ptr<ProfileManager> profile_manager_,
                              Core::System& system_, const char* name)
-    : ServiceFramework{system_, name}, module{std::move(module_)},
+    : ServiceFramework{system_, name}, module{std::move(module_)}, profile_manager{std::move(
-      profile_manager{std::move(profile_manager_)} {}
+                                                                       profile_manager_)} {}
 
 Module::Interface::~Interface() = default;
 

src/core/hle/service/am/frontend/applet_cabinet.cpp

@@ -18,8 +18,9 @@ namespace Service::AM::Frontend {
 
 Cabinet::Cabinet(Core::System& system_, std::shared_ptr<Applet> applet_,
                  LibraryAppletMode applet_mode_, const Core::Frontend::CabinetApplet& frontend_)
-    : FrontendApplet{system_, applet_, applet_mode_}, frontend{frontend_},
+    : FrontendApplet{system_, applet_, applet_mode_}, frontend{frontend_}, service_context{
-      service_context{system_, "CabinetApplet"} {
+                                                                               system_,
+                                                                               "CabinetApplet"} {
 
     availability_change_event =
         service_context.CreateEvent("CabinetApplet:AvailabilityChangeEvent");

src/core/hle/service/am/service/application_proxy.cpp

@@ -18,8 +18,8 @@ namespace Service::AM {
 
 IApplicationProxy::IApplicationProxy(Core::System& system_, std::shared_ptr<Applet> applet,
                                      Kernel::KProcess* process, WindowSystem& window_system)
-    : ServiceFramework{system_, "IApplicationProxy"}, m_window_system{window_system},
+    : ServiceFramework{system_, "IApplicationProxy"},
-      m_process{process}, m_applet{std::move(applet)} {
+      m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&IApplicationProxy::GetCommonStateGetter>, "GetCommonStateGetter"},

src/core/hle/service/am/service/library_applet_creator.cpp

@@ -165,8 +165,8 @@ std::shared_ptr<ILibraryAppletAccessor> CreateFrontendApplet(Core::System& syste
 
 ILibraryAppletCreator::ILibraryAppletCreator(Core::System& system_, std::shared_ptr<Applet> applet,
                                              WindowSystem& window_system)
-    : ServiceFramework{system_, "ILibraryAppletCreator"}, m_window_system{window_system},
+    : ServiceFramework{system_, "ILibraryAppletCreator"},
-      m_applet{std::move(applet)} {
+      m_window_system{window_system}, m_applet{std::move(applet)} {
     static const FunctionInfo functions[] = {
         {0, D<&ILibraryAppletCreator::CreateLibraryApplet>, "CreateLibraryApplet"},
         {1, nullptr, "TerminateAllLibraryApplets"},

src/core/hle/service/am/service/library_applet_proxy.cpp

@@ -20,8 +20,8 @@ namespace Service::AM {
 
 ILibraryAppletProxy::ILibraryAppletProxy(Core::System& system_, std::shared_ptr<Applet> applet,
                                          Kernel::KProcess* process, WindowSystem& window_system)
-    : ServiceFramework{system_, "ILibraryAppletProxy"}, m_window_system{window_system},
+    : ServiceFramework{system_, "ILibraryAppletProxy"},
-      m_process{process}, m_applet{std::move(applet)} {
+      m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&ILibraryAppletProxy::GetCommonStateGetter>, "GetCommonStateGetter"},

src/core/hle/service/am/service/self_controller.cpp

@@ -16,8 +16,8 @@ namespace Service::AM {
 
 ISelfController::ISelfController(Core::System& system_, std::shared_ptr<Applet> applet,
                                  Kernel::KProcess* process)
-    : ServiceFramework{system_, "ISelfController"}, m_process{process},
+    : ServiceFramework{system_, "ISelfController"}, m_process{process}, m_applet{
-      m_applet{std::move(applet)} {
+                                                                            std::move(applet)} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&ISelfController::Exit>, "Exit"},

src/core/hle/service/am/service/system_applet_proxy.cpp

@@ -20,8 +20,8 @@ namespace Service::AM {
 
 ISystemAppletProxy::ISystemAppletProxy(Core::System& system_, std::shared_ptr<Applet> applet,
                                        Kernel::KProcess* process, WindowSystem& window_system)
-    : ServiceFramework{system_, "ISystemAppletProxy"}, m_window_system{window_system},
+    : ServiceFramework{system_, "ISystemAppletProxy"},
-      m_process{process}, m_applet{std::move(applet)} {
+      m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&ISystemAppletProxy::GetCommonStateGetter>, "GetCommonStateGetter"},

src/core/hle/service/am/service/window_controller.cpp

@@ -11,8 +11,8 @@ namespace Service::AM {
 
 IWindowController::IWindowController(Core::System& system_, std::shared_ptr<Applet> applet,
                                      WindowSystem& window_system)
-    : ServiceFramework{system_, "IWindowController"}, m_window_system{window_system},
+    : ServiceFramework{system_, "IWindowController"},
-      m_applet{std::move(applet)} {
+      m_window_system{window_system}, m_applet{std::move(applet)} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "CreateWindow"},

src/core/hle/service/aoc/purchase_event_manager.cpp

@@ -9,8 +9,8 @@ namespace Service::AOC {
 constexpr Result ResultNoPurchasedProductInfoAvailable{ErrorModule::NIMShop, 400};
 
 IPurchaseEventManager::IPurchaseEventManager(Core::System& system_)
-    : ServiceFramework{system_, "IPurchaseEventManager"},
+    : ServiceFramework{system_, "IPurchaseEventManager"}, service_context{system,
-      service_context{system, "IPurchaseEventManager"} {
+                                                                          "IPurchaseEventManager"} {
     // clang-format off
         static const FunctionInfo functions[] = {
             {0, D<&IPurchaseEventManager::SetDefaultDeliveryTarget>, "SetDefaultDeliveryTarget"},

src/core/hle/service/audio/audio_in.cpp

@@ -12,8 +12,9 @@ IAudioIn::IAudioIn(Core::System& system_, Manager& manager, size_t session_id,
                    const std::string& device_name, const AudioInParameter& in_params,
                    Kernel::KProcess* handle, u64 applet_resource_user_id)
     : ServiceFramework{system_, "IAudioIn"}, process{handle}, service_context{system_, "IAudioIn"},
-      event{service_context.CreateEvent("AudioInEvent")},
+      event{service_context.CreateEvent("AudioInEvent")}, impl{std::make_shared<In>(system_,
-      impl{std::make_shared<In>(system_, manager, event, session_id)} {
+                                                                                    manager, event,
+                                                                                    session_id)} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&IAudioIn::GetAudioInState>, "GetAudioInState"},

src/core/hle/service/audio/audio_in_manager.cpp

@@ -10,8 +10,8 @@ namespace Service::Audio {
 using namespace AudioCore::AudioIn;
 
 IAudioInManager::IAudioInManager(Core::System& system_)
-    : ServiceFramework{system_, "audin:u"},
+    : ServiceFramework{system_, "audin:u"}, impl{std::make_unique<AudioCore::AudioIn::Manager>(
-      impl{std::make_unique<AudioCore::AudioIn::Manager>(system_)} {
+                                                system_)} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&IAudioInManager::ListAudioIns>, "ListAudioIns"},

src/core/hle/service/audio/audio_renderer.cpp

@@ -14,8 +14,8 @@ IAudioRenderer::IAudioRenderer(Core::System& system_, Manager& manager_,
                                s32 session_id)
     : ServiceFramework{system_, "IAudioRenderer"}, service_context{system_, "IAudioRenderer"},
       rendered_event{service_context.CreateEvent("IAudioRendererEvent")}, manager{manager_},
-      impl{std::make_unique<Renderer>(system_, manager, rendered_event)},
+      impl{std::make_unique<Renderer>(system_, manager, rendered_event)}, process_handle{
-      process_handle{process_handle_} {
+                                                                              process_handle_} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&IAudioRenderer::GetSampleRate>, "GetSampleRate"},

src/core/hle/service/bcat/news/newly_arrived_event_holder.cpp

@@ -7,8 +7,9 @@
 namespace Service::News {
 
 INewlyArrivedEventHolder::INewlyArrivedEventHolder(Core::System& system_)
-    : ServiceFramework{system_, "INewlyArrivedEventHolder"},
+    : ServiceFramework{system_, "INewlyArrivedEventHolder"}, service_context{
-      service_context{system_, "INewlyArrivedEventHolder"} {
+                                                                 system_,
+                                                                 "INewlyArrivedEventHolder"} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&INewlyArrivedEventHolder::Get>, "Get"},

src/core/hle/service/bcat/news/overwrite_event_holder.cpp

@@ -7,8 +7,8 @@
 namespace Service::News {
 
 IOverwriteEventHolder::IOverwriteEventHolder(Core::System& system_)
-    : ServiceFramework{system_, "IOverwriteEventHolder"},
+    : ServiceFramework{system_, "IOverwriteEventHolder"}, service_context{system_,
-      service_context{system_, "IOverwriteEventHolder"} {
+                                                                          "IOverwriteEventHolder"} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&IOverwriteEventHolder::Get>, "Get"},

src/core/hle/service/filesystem/fsp/fs_i_filesystem.cpp

@@ -11,8 +11,8 @@
 namespace Service::FileSystem {
 
 IFileSystem::IFileSystem(Core::System& system_, FileSys::VirtualDir dir_, SizeGetter size_getter_)
-    : ServiceFramework{system_, "IFileSystem"},
+    : ServiceFramework{system_, "IFileSystem"}, backend{std::make_unique<FileSys::Fsa::IFileSystem>(
-      backend{std::make_unique<FileSys::Fsa::IFileSystem>(dir_)},
+                                                    dir_)},
       size_getter{std::move(size_getter_)} {
     static const FunctionInfo functions[] = {
         {0, D<&IFileSystem::CreateFile>, "CreateFile"},

src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp

@@ -12,8 +12,8 @@ namespace Service::FileSystem {
 ISaveDataInfoReader::ISaveDataInfoReader(Core::System& system_,
                                          std::shared_ptr<SaveDataController> save_data_controller_,
                                          FileSys::SaveDataSpaceId space)
-    : ServiceFramework{system_, "ISaveDataInfoReader"},
+    : ServiceFramework{system_, "ISaveDataInfoReader"}, save_data_controller{
-      save_data_controller{save_data_controller_} {
+                                                            save_data_controller_} {
     static const FunctionInfo functions[] = {
         {0, D<&ISaveDataInfoReader::ReadSaveDataInfo>, "ReadSaveDataInfo"},
     };

src/core/hle/service/glue/time/alarm_worker.cpp

@@ -11,8 +11,8 @@
 namespace Service::Glue::Time {
 
 AlarmWorker::AlarmWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource)
-    : m_system{system}, m_ctx{system, "Glue:AlarmWorker"},
+    : m_system{system}, m_ctx{system, "Glue:AlarmWorker"}, m_steady_clock_resource{
-      m_steady_clock_resource{steady_clock_resource} {}
+                                                               steady_clock_resource} {}
 
 AlarmWorker::~AlarmWorker() {
     m_system.CoreTiming().UnscheduleEvent(m_timer_timing_event);

src/core/hle/service/glue/time/manager.cpp

@@ -87,8 +87,10 @@ static Service::PSC::Time::LocationName GetTimeZoneString(
 }
 
 TimeManager::TimeManager(Core::System& system)
-    : m_steady_clock_resource{system}, m_time_zone_binary{system},
+    : m_steady_clock_resource{system}, m_time_zone_binary{system}, m_worker{
-      m_worker{system, m_steady_clock_resource, m_file_timestamp_worker} {
+                                                                       system,
+                                                                       m_steady_clock_resource,
+                                                                       m_file_timestamp_worker} {
     m_time_m =
         system.ServiceManager().GetService<Service::PSC::Time::ServiceManager>("time:m", true);
 

src/core/hle/service/glue/time/time_zone.cpp

@@ -22,9 +22,9 @@ TimeZoneService::TimeZoneService(
     std::shared_ptr<Service::PSC::Time::TimeZoneService> time_zone_service)
     : ServiceFramework{system_, "ITimeZoneService"}, m_system{system},
       m_can_write_timezone_device_location{can_write_timezone_device_location},
-      m_file_timestamp_worker{file_timestamp_worker},
+      m_file_timestamp_worker{file_timestamp_worker}, m_wrapped_service{std::move(
-      m_wrapped_service{std::move(time_zone_service)}, m_operation_event{m_system},
+                                                          time_zone_service)},
-      m_time_zone_binary{time_zone_binary} {
+      m_operation_event{m_system}, m_time_zone_binary{time_zone_binary} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0,   D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"},

src/core/hle/service/glue/time/worker.cpp

@@ -19,11 +19,11 @@ namespace Service::Glue::Time {
 
 TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource,
                        FileTimestampWorker& file_timestamp_worker)
-    : m_system{system}, m_ctx{m_system, "Glue:TimeWorker"},
+    : m_system{system}, m_ctx{m_system, "Glue:TimeWorker"}, m_event{m_ctx.CreateEvent(
-      m_event{m_ctx.CreateEvent("Glue:TimeWorker:Event")},
+                                                                "Glue:TimeWorker:Event")},
       m_steady_clock_resource{steady_clock_resource},
-      m_file_timestamp_worker{file_timestamp_worker},
+      m_file_timestamp_worker{file_timestamp_worker}, m_timer_steady_clock{m_ctx.CreateEvent(
-      m_timer_steady_clock{m_ctx.CreateEvent("Glue:TimeWorker:SteadyClockTimerEvent")},
+                                                          "Glue:TimeWorker:SteadyClockTimerEvent")},
       m_timer_file_system{m_ctx.CreateEvent("Glue:TimeWorker:FileTimeTimerEvent")},
       m_alarm_worker{m_system, m_steady_clock_resource}, m_pm_state_change_handler{m_alarm_worker} {
     m_timer_steady_clock_timing_event = Core::Timing::CreateEvent(

src/core/hle/service/hid/hid_debug_server.cpp

@@ -17,8 +17,8 @@ namespace Service::HID {
 
 IHidDebugServer::IHidDebugServer(Core::System& system_, std::shared_ptr<ResourceManager> resource,
                                  std::shared_ptr<HidFirmwareSettings> settings)
-    : ServiceFramework{system_, "hid:dbg"}, resource_manager{resource},
+    : ServiceFramework{system_, "hid:dbg"}, resource_manager{resource}, firmware_settings{
-      firmware_settings{settings} {
+                                                                            settings} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "DeactivateDebugPad"},

src/core/hle/service/ipc_helpers.h

@@ -72,8 +72,8 @@ public:
                              u32 num_handles_to_copy_ = 0, u32 num_objects_to_move_ = 0,
                              Flags flags = Flags::None)
         : RequestHelperBase(ctx), normal_params_size(normal_params_size_),
-          num_handles_to_copy(num_handles_to_copy_), num_objects_to_move(num_objects_to_move_),
+          num_handles_to_copy(num_handles_to_copy_),
-          kernel{ctx.kernel} {
+          num_objects_to_move(num_objects_to_move_), kernel{ctx.kernel} {
 
         memset(cmdbuf, 0, sizeof(u32) * IPC::COMMAND_BUFFER_LENGTH);
 

src/core/hle/service/jit/jit_context.cpp

@@ -40,8 +40,8 @@ class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
 public:
     explicit DynarmicCallbacks64(Core::Memory::Memory& memory_, std::vector<u8>& local_memory_,
                                  IntervalSet& mapped_ranges_, JITContextImpl& parent_)
-        : memory{memory_}, local_memory{local_memory_}, mapped_ranges{mapped_ranges_},
+        : memory{memory_}, local_memory{local_memory_},
-          parent{parent_} {}
+          mapped_ranges{mapped_ranges_}, parent{parent_} {}
 
     u8 MemoryRead8(u64 vaddr) override {
         return ReadMemory<u8>(vaddr);

src/core/hle/service/mii/mii.cpp

@@ -23,8 +23,8 @@ class IDatabaseService final : public ServiceFramework<IDatabaseService> {
 public:
     explicit IDatabaseService(Core::System& system_, std::shared_ptr<MiiManager> mii_manager,
                               bool is_system_)
-        : ServiceFramework{system_, "IDatabaseService"}, manager{mii_manager},
+        : ServiceFramework{system_, "IDatabaseService"}, manager{mii_manager}, is_system{
-          is_system{is_system_} {
+                                                                                   is_system_} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, D<&IDatabaseService::IsUpdated>, "IsUpdated"},

src/core/hle/service/psc/time/alarms.cpp

@@ -30,8 +30,8 @@ Alarm::~Alarm() {
 Alarms::Alarms(Core::System& system, StandardSteadyClockCore& steady_clock,
                PowerStateRequestManager& power_state_request_manager)
     : m_system{system}, m_ctx{system, "Psc:Alarms"}, m_steady_clock{steady_clock},
-      m_power_state_request_manager{power_state_request_manager},
+      m_power_state_request_manager{power_state_request_manager}, m_event{m_ctx.CreateEvent(
-      m_event{m_ctx.CreateEvent("Psc:Alarms:Event")} {}
+                                                                      "Psc:Alarms:Event")} {}
 
 Alarms::~Alarms() {
     m_ctx.CloseEvent(m_event);

src/core/hle/service/psc/time/clocks/standard_user_system_clock_core.cpp

@@ -11,8 +11,8 @@ StandardUserSystemClockCore::StandardUserSystemClockCore(
     StandardNetworkSystemClockCore& network_clock)
     : SystemClockCore{local_clock.GetSteadyClock()}, m_system{system},
       m_ctx{m_system, "Psc:StandardUserSystemClockCore"}, m_local_system_clock{local_clock},
-      m_network_system_clock{network_clock},
+      m_network_system_clock{network_clock}, m_event{m_ctx.CreateEvent(
-      m_event{m_ctx.CreateEvent("Psc:StandardUserSystemClockCore:Event")} {}
+                                                 "Psc:StandardUserSystemClockCore:Event")} {}
 
 StandardUserSystemClockCore::~StandardUserSystemClockCore() {
     m_ctx.CloseEvent(m_event);

src/core/hle/service/psc/time/common.cpp

@@ -6,8 +6,8 @@
 
 namespace Service::PSC::Time {
 OperationEvent::OperationEvent(Core::System& system)
-    : m_ctx{system, "Time:OperationEvent"},
+    : m_ctx{system, "Time:OperationEvent"}, m_event{
-      m_event{m_ctx.CreateEvent("Time:OperationEvent:Event")} {}
+                                                m_ctx.CreateEvent("Time:OperationEvent:Event")} {}
 
 OperationEvent::~OperationEvent() {
     m_ctx.CloseEvent(m_event);

src/core/hle/service/psc/time/manager.h

@@ -29,8 +29,8 @@ public:
           m_standard_user_system_clock{m_system, m_standard_local_system_clock,
                                        m_standard_network_system_clock},
           m_ephemeral_network_clock{m_tick_based_steady_clock}, m_shared_memory{m_system},
-          m_power_state_request_manager{m_system},
+          m_power_state_request_manager{m_system}, m_alarms{m_system, m_standard_steady_clock,
-          m_alarms{m_system, m_standard_steady_clock, m_power_state_request_manager},
+                                                            m_power_state_request_manager},
           m_local_system_clock_context_writer{m_system, m_shared_memory},
           m_network_system_clock_context_writer{m_system, m_shared_memory,
                                                 m_standard_user_system_clock},

src/core/hle/service/psc/time/power_state_service.cpp

@@ -8,8 +8,8 @@ namespace Service::PSC::Time {
 
 IPowerStateRequestHandler::IPowerStateRequestHandler(
     Core::System& system_, PowerStateRequestManager& power_state_request_manager)
-    : ServiceFramework{system_, "time:p"}, m_system{system},
+    : ServiceFramework{system_, "time:p"}, m_system{system}, m_power_state_request_manager{
-      m_power_state_request_manager{power_state_request_manager} {
+                                                                 power_state_request_manager} {
     // clang-format off
         static const FunctionInfo functions[] = {
             {0, D<&IPowerStateRequestHandler::GetPowerStateRequestEventReadableHandle>, "GetPowerStateRequestEventReadableHandle"},

src/core/hle/service/psc/time/static.cpp

@@ -37,8 +37,8 @@ StaticService::StaticService(Core::System& system_, StaticServiceSetupInfo setup
       m_user_system_clock{m_time->m_standard_user_system_clock},
       m_network_system_clock{m_time->m_standard_network_system_clock},
       m_time_zone{m_time->m_time_zone},
-      m_ephemeral_network_clock{m_time->m_ephemeral_network_clock},
+      m_ephemeral_network_clock{m_time->m_ephemeral_network_clock}, m_shared_memory{
-      m_shared_memory{m_time->m_shared_memory} {
+                                                                        m_time->m_shared_memory} {
     // clang-format off
         static const FunctionInfo functions[] = {
             {0,   D<&StaticService::GetStandardUserSystemClock>, "GetStandardUserSystemClock"},

src/core/hle/service/psc/time/steady_clock.cpp

@@ -12,8 +12,8 @@ SteadyClock::SteadyClock(Core::System& system_, std::shared_ptr<TimeManager> man
                          bool can_write_steady_clock, bool can_write_uninitialized_clock)
     : ServiceFramework{system_, "ISteadyClock"}, m_system{system},
       m_clock_core{manager->m_standard_steady_clock},
-      m_can_write_steady_clock{can_write_steady_clock},
+      m_can_write_steady_clock{can_write_steady_clock}, m_can_write_uninitialized_clock{
-      m_can_write_uninitialized_clock{can_write_uninitialized_clock} {
+                                                            can_write_uninitialized_clock} {
     // clang-format off
          static const FunctionInfo functions[] = {
         {0, D<&SteadyClock::GetCurrentTimePoint>, "GetCurrentTimePoint"},

src/core/hle/service/psc/time/system_clock.cpp

@@ -11,8 +11,8 @@ namespace Service::PSC::Time {
 SystemClock::SystemClock(Core::System& system_, SystemClockCore& clock_core, bool can_write_clock,
                          bool can_write_uninitialized_clock)
     : ServiceFramework{system_, "ISystemClock"}, m_system{system}, m_clock_core{clock_core},
-      m_can_write_clock{can_write_clock},
+      m_can_write_clock{can_write_clock}, m_can_write_uninitialized_clock{
-      m_can_write_uninitialized_clock{can_write_uninitialized_clock} {
+                                              can_write_uninitialized_clock} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&SystemClock::GetCurrentTime>, "GetCurrentTime"},

src/core/hle/service/psc/time/time_zone_service.cpp

@@ -13,8 +13,8 @@ namespace Service::PSC::Time {
 TimeZoneService::TimeZoneService(Core::System& system_, StandardSteadyClockCore& clock_core,
                                  TimeZone& time_zone, bool can_write_timezone_device_location)
     : ServiceFramework{system_, "ITimeZoneService"}, m_system{system}, m_clock_core{clock_core},
-      m_time_zone{time_zone},
+      m_time_zone{time_zone}, m_can_write_timezone_device_location{
-      m_can_write_timezone_device_location{can_write_timezone_device_location} {
+                                  can_write_timezone_device_location} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0,   D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"},

src/core/hle/service/sm/sm.cpp

@@ -251,8 +251,8 @@ void SM::UnregisterService(HLERequestContext& ctx) {
 }
 
 SM::SM(ServiceManager& service_manager_, Core::System& system_)
-    : ServiceFramework{system_, "sm:", 4}, service_manager{service_manager_},
+    : ServiceFramework{system_, "sm:", 4},
-      kernel{system_.Kernel()} {
+      service_manager{service_manager_}, kernel{system_.Kernel()} {
     RegisterHandlers({
         {0, &SM::Initialize, "Initialize"},
         {1, &SM::GetServiceCmif, "GetService"},

src/core/hle/service/vi/application_display_service.cpp

@@ -15,8 +15,8 @@ namespace Service::VI {
 
 IApplicationDisplayService::IApplicationDisplayService(Core::System& system_,
                                                        std::shared_ptr<Container> container)
-    : ServiceFramework{system_, "IApplicationDisplayService"}, m_container{std::move(container)},
+    : ServiceFramework{system_, "IApplicationDisplayService"},
-      m_context{system, "IApplicationDisplayService"} {
+      m_container{std::move(container)}, m_context{system, "IApplicationDisplayService"} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {100, C<&IApplicationDisplayService::GetRelayService>, "GetRelayService"},

src/core/memory/cheat_engine.cpp

@@ -218,8 +218,8 @@ std::vector<CheatEntry> TextCheatParser::Parse(std::string_view data) const {
 
 CheatEngine::CheatEngine(System& system_, std::vector<CheatEntry> cheats_,
                          const std::array<u8, 0x20>& build_id_)
-    : vm{std::make_unique<StandardVmCallbacks>(system_, metadata)}, cheats(std::move(cheats_)),
+    : vm{std::make_unique<StandardVmCallbacks>(system_, metadata)},
-      core_timing{system_.CoreTiming()}, system{system_} {
+      cheats(std::move(cheats_)), core_timing{system_.CoreTiming()}, system{system_} {
     metadata.main_nso_build_id = build_id_;
 }
 

src/input_common/input_poller.cpp

@@ -148,8 +148,8 @@ public:
                             Common::Input::AnalogProperties properties_y_,
                             InputEngine* input_engine_)
         : identifier(identifier_), axis_x(axis_x_), axis_y(axis_y_), properties_x(properties_x_),
-          properties_y(properties_y_), input_engine(input_engine_),
+          properties_y(properties_y_),
-          invert_axis_y{input_engine_->GetEngineName() == "sdl"} {
+          input_engine(input_engine_), invert_axis_y{input_engine_->GetEngineName() == "sdl"} {
         UpdateCallback engine_callback{[this]() { OnChange(); }};
         const InputIdentifier x_input_identifier{
             .identifier = identifier,

src/shader_recompiler/frontend/maxwell/control_flow.cpp

@@ -186,8 +186,8 @@ Function::Function(ObjectPool<Block>& block_pool, Location start_address)
 
 CFG::CFG(Environment& env_, ObjectPool<Block>& block_pool_, Location start_address,
          bool exits_to_dispatcher_)
-    : env{env_}, block_pool{block_pool_}, program_start{start_address},
+    : env{env_}, block_pool{block_pool_}, program_start{start_address}, exits_to_dispatcher{
-      exits_to_dispatcher{exits_to_dispatcher_} {
+                                                                            exits_to_dispatcher_} {
     if (exits_to_dispatcher) {
         dispatch_block = block_pool.Create(Block{});
         dispatch_block->begin = {};

src/shader_recompiler/frontend/maxwell/structured_control_flow.cpp

@@ -112,8 +112,8 @@ struct Statement : ListBaseHook {
     Statement(SetVariable, u32 id_, Statement* op_, Statement* up_)
         : op{op_}, id{id_}, up{up_}, type{StatementType::SetVariable} {}
     Statement(SetIndirectBranchVariable, IR::Reg branch_reg_, s32 branch_offset_, Statement* up_)
-        : branch_offset{branch_offset_}, branch_reg{branch_reg_}, up{up_},
+        : branch_offset{branch_offset_},
-          type{StatementType::SetIndirectBranchVariable} {}
+          branch_reg{branch_reg_}, up{up_}, type{StatementType::SetIndirectBranchVariable} {}
     Statement(Variable, u32 id_, Statement* up_)
         : id{id_}, up{up_}, type{StatementType::Variable} {}
     Statement(IndirectBranchCond, u32 location_, Statement* up_)

src/suyu/applets/qt_web_browser.cpp

@@ -54,8 +54,8 @@ QtNXWebEngineView::QtNXWebEngineView(QWidget* parent, Core::System& system,
     : QWebEngineView(parent), input_subsystem{input_subsystem_},
       url_interceptor(std::make_unique<UrlRequestInterceptor>()),
       input_interpreter(std::make_unique<InputInterpreter>(system)),
-      default_profile{QWebEngineProfile::defaultProfile()},
+      default_profile{QWebEngineProfile::defaultProfile()}, global_settings{
-      global_settings{default_profile->settings()} {
+                                                                default_profile->settings()} {
     default_profile->setPersistentStoragePath(QString::fromStdString(Common::FS::PathToUTF8String(
         Common::FS::GetSuyuPath(Common::FS::SuyuPath::SuyuDir) / "qtwebengine")));
 

src/suyu/bootmanager.cpp

@@ -284,8 +284,8 @@ struct NullRenderWidget : public RenderWidget {
 GRenderWindow::GRenderWindow(GMainWindow* parent, EmuThread* emu_thread_,
                              std::shared_ptr<InputCommon::InputSubsystem> input_subsystem_,
                              Core::System& system_)
-    : QWidget(parent), emu_thread(emu_thread_), input_subsystem{std::move(input_subsystem_)},
+    : QWidget(parent),
-      system{system_} {
+      emu_thread(emu_thread_), input_subsystem{std::move(input_subsystem_)}, system{system_} {
     setWindowTitle(QStringLiteral("suyu %1 | %2-%3")
                        .arg(QString::fromUtf8(Common::g_build_name),
                             QString::fromUtf8(Common::g_scm_branch),

src/suyu/configuration/configure_dialog.cpp

@@ -32,9 +32,9 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry_,
                                  InputCommon::InputSubsystem* input_subsystem,
                                  std::vector<VkDeviceInfo::Record>& vk_device_records,
                                  Core::System& system_, bool enable_web_config)
-    : QDialog(parent), ui{std::make_unique<Ui::ConfigureDialog>()}, registry(registry_),
+    : QDialog(parent), ui{std::make_unique<Ui::ConfigureDialog>()},
-      system{system_},
+      registry(registry_), system{system_}, builder{std::make_unique<ConfigurationShared::Builder>(
-      builder{std::make_unique<ConfigurationShared::Builder>(this, !system_.IsPoweredOn())},
+                                                this, !system_.IsPoweredOn())},
       applets_tab{std::make_unique<ConfigureApplets>(system_, nullptr, *builder, this)},
       audio_tab{std::make_unique<ConfigureAudio>(system_, nullptr, *builder, this)},
       cpu_tab{std::make_unique<ConfigureCpu>(system_, nullptr, *builder, this)},

src/suyu/configuration/configure_input_player.cpp

@@ -293,11 +293,11 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
                                            InputCommon::InputSubsystem* input_subsystem_,
                                            InputProfiles* profiles_, Core::HID::HIDCore& hid_core_,
                                            bool is_powered_on_, bool debug_)
-    : QWidget(parent), ui(std::make_unique<Ui::ConfigureInputPlayer>()),
+    : QWidget(parent),
-      player_index{player_index_}, debug{debug_}, is_powered_on{is_powered_on_},
+      ui(std::make_unique<Ui::ConfigureInputPlayer>()), player_index{player_index_}, debug{debug_},
-      input_subsystem{input_subsystem_}, profiles(profiles_),
+      is_powered_on{is_powered_on_}, input_subsystem{input_subsystem_}, profiles(profiles_),
-      timeout_timer(std::make_unique<QTimer>()), poll_timer(std::make_unique<QTimer>()),
+      timeout_timer(std::make_unique<QTimer>()),
-      bottom_row{bottom_row_}, hid_core{hid_core_} {
+      poll_timer(std::make_unique<QTimer>()), bottom_row{bottom_row_}, hid_core{hid_core_} {
     if (player_index == 0) {
         auto* emulated_controller_p1 =
             hid_core.GetEmulatedController(Core::HID::NpadIdType::Player1);

src/suyu/configuration/configure_per_game.cpp

@@ -44,8 +44,8 @@
 ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const std::string& file_name,
                                    std::vector<VkDeviceInfo::Record>& vk_device_records,
                                    Core::System& system_)
-    : QDialog(parent), ui(std::make_unique<Ui::ConfigurePerGame>()), title_id{title_id_},
+    : QDialog(parent),
-      system{system_},
+      ui(std::make_unique<Ui::ConfigurePerGame>()), title_id{title_id_}, system{system_},
       builder{std::make_unique<ConfigurationShared::Builder>(this, !system_.IsPoweredOn())},
       tab_group{std::make_shared<std::vector<ConfigurationShared::Tab*>>()} {
     const auto file_path = std::filesystem::path(Common::FS::ToU8String(file_name));

src/suyu/configuration/shared_widget.cpp

@@ -766,8 +766,8 @@ Widget::Widget(Settings::BasicSetting* setting_, const TranslationMap& translati
 
 Builder::Builder(QWidget* parent_, bool runtime_lock_)
     : translations{InitializeTranslations(parent_)},
-      combobox_translations{ComboboxEnumeration(parent_)}, parent{parent_},
+      combobox_translations{ComboboxEnumeration(parent_)}, parent{parent_}, runtime_lock{
-      runtime_lock{runtime_lock_} {}
+                                                                                runtime_lock_} {}
 
 Builder::~Builder() = default;
 

src/suyu/game_list_worker.cpp

@@ -234,8 +234,8 @@ GameListWorker::GameListWorker(FileSys::VirtualFilesystem vfs_,
                                const PlayTime::PlayTimeManager& play_time_manager_,
                                Core::System& system_)
     : vfs{std::move(vfs_)}, provider{provider_}, game_dirs{game_dirs_},
-      compatibility_list{compatibility_list_}, play_time_manager{play_time_manager_},
+      compatibility_list{compatibility_list_}, play_time_manager{play_time_manager_}, system{
-      system{system_} {
+                                                                                          system_} {
     // We want the game list to manage our lifetime.
     setAutoDelete(false);
 }

src/suyu/multiplayer/direct_connect.cpp

@@ -24,8 +24,8 @@ enum class ConnectionType : u8 { TraversalServer, IP };
 
 DirectConnectWindow::DirectConnectWindow(Core::System& system_, QWidget* parent)
     : QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint),
-      ui(std::make_unique<Ui::DirectConnect>()), system{system_},
+      ui(std::make_unique<Ui::DirectConnect>()), system{system_}, room_network{
-      room_network{system.GetRoomNetwork()} {
+                                                                      system.GetRoomNetwork()} {
 
     ui->setupUi(this);
 

src/suyu/multiplayer/host_room.cpp

@@ -31,8 +31,9 @@ HostRoomWindow::HostRoomWindow(QWidget* parent, QStandardItemModel* list,
                                std::shared_ptr<Core::AnnounceMultiplayerSession> session,
                                Core::System& system_)
     : QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint),
-      ui(std::make_unique<Ui::HostRoom>()), announce_multiplayer_session(session), system{system_},
+      ui(std::make_unique<Ui::HostRoom>()),
-      room_network{system.GetRoomNetwork()} {
+      announce_multiplayer_session(session), system{system_}, room_network{
+                                                                  system.GetRoomNetwork()} {
     ui->setupUi(this);
 
     // set up validation for all of the fields

src/suyu/multiplayer/lobby.cpp

@@ -27,8 +27,9 @@
 Lobby::Lobby(QWidget* parent, QStandardItemModel* list,
              std::shared_ptr<Core::AnnounceMultiplayerSession> session, Core::System& system_)
     : QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint),
-      ui(std::make_unique<Ui::Lobby>()), announce_multiplayer_session(session), system{system_},
+      ui(std::make_unique<Ui::Lobby>()),
-      room_network{system.GetRoomNetwork()} {
+      announce_multiplayer_session(session), system{system_}, room_network{
+                                                                  system.GetRoomNetwork()} {
     ui->setupUi(this);
 
     // setup the watcher for background connections

src/video_core/cdma_pusher.cpp

@@ -18,8 +18,8 @@ namespace Tegra {
 
 CDmaPusher::CDmaPusher(Host1x::Host1x& host1x_, s32 id)
     : host1x{host1x_}, memory_manager{host1x.GMMU()},
-      host_processor{std::make_unique<Host1x::Control>(host1x_)},
+      host_processor{std::make_unique<Host1x::Control>(host1x_)}, current_class{
-      current_class{static_cast<ChClassId>(id)} {
+                                                                      static_cast<ChClassId>(id)} {
     thread = std::jthread([this](std::stop_token stop_token) { ProcessEntries(stop_token); });
 }
 

src/video_core/dma_pusher.cpp

@@ -18,8 +18,8 @@ constexpr u32 ComputeInline = 0x6D;
 
 DmaPusher::DmaPusher(Core::System& system_, GPU& gpu_, MemoryManager& memory_manager_,
                      Control::ChannelState& channel_state_)
-    : gpu{gpu_}, system{system_}, memory_manager{memory_manager_},
+    : gpu{gpu_}, system{system_}, memory_manager{memory_manager_}, puller{gpu_, memory_manager_,
-      puller{gpu_, memory_manager_, *this, channel_state_} {}
+                                                                          *this, channel_state_} {}
 
 DmaPusher::~DmaPusher() = default;
 

src/video_core/engines/maxwell_3d.cpp

@@ -24,8 +24,9 @@ constexpr u32 MacroRegistersStart = 0xE00;
 
 Maxwell3D::Maxwell3D(Core::System& system_, MemoryManager& memory_manager_)
     : draw_manager{std::make_unique<DrawManager>(this)}, system{system_},
-      memory_manager{memory_manager_}, macro_engine{GetMacroEngine(*this)},
+      memory_manager{memory_manager_}, macro_engine{GetMacroEngine(*this)}, upload_state{
-      upload_state{memory_manager, regs.upload} {
+                                                                                memory_manager,
+                                                                                regs.upload} {
     dirty.flags.flip();
     InitializeRegisterDefaults();
     execution_mask.reset();

src/video_core/engines/puller.cpp

@@ -21,8 +21,8 @@ namespace Tegra::Engines {
 
 Puller::Puller(GPU& gpu_, MemoryManager& memory_manager_, DmaPusher& dma_pusher_,
                Control::ChannelState& channel_state_)
-    : gpu{gpu_}, memory_manager{memory_manager_}, dma_pusher{dma_pusher_},
+    : gpu{gpu_}, memory_manager{memory_manager_}, dma_pusher{dma_pusher_}, channel_state{
-      channel_state{channel_state_} {}
+                                                                               channel_state_} {}
 
 Puller::~Puller() = default;
 

src/video_core/host1x/codecs/decoder.cpp

@@ -11,8 +11,8 @@ namespace Tegra {
 
 Decoder::Decoder(Host1x::Host1x& host1x_, s32 id_, const Host1x::NvdecCommon::NvdecRegisters& regs_,
                  Host1x::FrameQueue& frame_queue_)
-    : host1x(host1x_), memory_manager{host1x.GMMU()}, regs{regs_}, id{id_},
+    : host1x(host1x_), memory_manager{host1x.GMMU()}, regs{regs_}, id{id_}, frame_queue{
-      frame_queue{frame_queue_} {}
+                                                                                frame_queue_} {}
 
 Decoder::~Decoder() = default;
 

src/video_core/host1x/host1x.cpp

@@ -9,8 +9,8 @@
 namespace Tegra::Host1x {
 
 Host1x::Host1x(Core::System& system_)
-    : system{system_}, syncpoint_manager{}, memory_manager(system.DeviceMemory()),
+    : system{system_}, syncpoint_manager{},
-      gmmu_manager{system, memory_manager, 32, 0, 12},
+      memory_manager(system.DeviceMemory()), gmmu_manager{system, memory_manager, 32, 0, 12},
       allocator{std::make_unique<Common::FlatAllocator<u32, 0, 32>>(1 << 12)} {}
 
 Host1x::~Host1x() = default;

src/video_core/host1x/vic.cpp

@@ -94,8 +94,8 @@ void SwizzleSurface(std::span<u8> output, u32 out_stride, std::span<const u8> in
 } // namespace
 
 Vic::Vic(Host1x& host1x_, s32 id_, u32 syncpt, FrameQueue& frame_queue_)
-    : CDmaPusher{host1x_, id_}, id{id_}, syncpoint{syncpt}, frame_queue{frame_queue_},
+    : CDmaPusher{host1x_, id_}, id{id_}, syncpoint{syncpt},
-      has_sse41{HasSSE41()} {
+      frame_queue{frame_queue_}, has_sse41{HasSSE41()} {
     LOG_INFO(HW_GPU, "Created vic {}", id);
 }
 

src/video_core/memory_manager.cpp

@@ -28,8 +28,8 @@ MemoryManager::MemoryManager(Core::System& system_, MaxwellDeviceMemoryManager&
       split_address{split_address_}, page_bits{page_bits_}, big_page_bits{big_page_bits_},
       entries{}, big_entries{}, page_table{address_space_bits, address_space_bits + page_bits - 38,
                                            page_bits != big_page_bits ? page_bits : 0},
-      kind_map{PTEKind::INVALID},
+      kind_map{PTEKind::INVALID}, unique_identifier{unique_identifier_generator.fetch_add(
-      unique_identifier{unique_identifier_generator.fetch_add(1, std::memory_order_acq_rel)},
+                                      1, std::memory_order_acq_rel)},
       accumulator{std::make_unique<VideoCommon::InvalidationAccumulator>()} {
     address_space_size = 1ULL << address_space_bits;
     page_size = 1ULL << page_bits;

src/video_core/query_cache/query_cache.h

@@ -115,8 +115,8 @@ struct QueryCacheBase<Traits>::QueryCacheBaseImpl {
     QueryCacheBaseImpl(QueryCacheBase<Traits>* owner_, VideoCore::RasterizerInterface& rasterizer_,
                        Tegra::MaxwellDeviceMemoryManager& device_memory_, RuntimeType& runtime_,
                        Tegra::GPU& gpu_)
-        : owner{owner_}, rasterizer{rasterizer_}, device_memory{device_memory_}, runtime{runtime_},
+        : owner{owner_}, rasterizer{rasterizer_},
-          gpu{gpu_} {
+          device_memory{device_memory_}, runtime{runtime_}, gpu{gpu_} {
         streamer_mask = 0;
         for (size_t i = 0; i < static_cast<size_t>(QueryType::MaxQueryTypes); i++) {
             streamers[i] = runtime.GetStreamerInterface(static_cast<QueryType>(i));

src/video_core/renderer_opengl/gl_compute_pipeline.cpp

@@ -31,8 +31,8 @@ ComputePipeline::ComputePipeline(const Device& device, TextureCache& texture_cac
                                  BufferCache& buffer_cache_, ProgramManager& program_manager_,
                                  const Shader::Info& info_, std::string code,
                                  std::vector<u32> code_v, bool force_context_flush)
-    : texture_cache{texture_cache_}, buffer_cache{buffer_cache_}, program_manager{program_manager_},
+    : texture_cache{texture_cache_}, buffer_cache{buffer_cache_},
-      info{info_} {
+      program_manager{program_manager_}, info{info_} {
     switch (device.GetShaderBackend()) {
     case Settings::ShaderBackend::Glsl:
         source_program = CreateProgram(code, GL_COMPUTE_SHADER);

src/video_core/renderer_opengl/gl_query_cache.cpp

@@ -66,8 +66,9 @@ bool QueryCache::AnyCommandQueued() const noexcept {
 
 HostCounter::HostCounter(QueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
                          VideoCore::QueryType type_)
-    : HostCounterBase{std::move(dependency_)}, cache{cache_}, type{type_},
+    : HostCounterBase{std::move(dependency_)}, cache{cache_}, type{type_}, query{
-      query{cache.AllocateQuery(type)} {
+                                                                               cache.AllocateQuery(
+                                                                                   type)} {
     glBeginQuery(GetTarget(type), query.handle);
 }
 

src/video_core/renderer_vulkan/present/fsr.cpp

@@ -24,8 +24,8 @@ using PushConstants = std::array<u32, 4 * 4>;
 
 FSR::FSR(const Device& device, MemoryAllocator& memory_allocator, size_t image_count,
          VkExtent2D extent)
-    : m_device{device}, m_memory_allocator{memory_allocator}, m_image_count{image_count},
+    : m_device{device}, m_memory_allocator{memory_allocator},
-      m_extent{extent} {
+      m_image_count{image_count}, m_extent{extent} {
 
     CreateImages();
     CreateRenderPasses();

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -531,8 +531,8 @@ ASTCDecoderPass::ASTCDecoderPass(const Device& device_, Scheduler& scheduler_,
                   ASTC_PASS_DESCRIPTOR_UPDATE_TEMPLATE_ENTRY, ASTC_BANK_INFO,
                   COMPUTE_PUSH_CONSTANT_RANGE<sizeof(AstcPushConstants)>, ASTC_DECODER_COMP_SPV),
       scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
-      compute_pass_descriptor_queue{compute_pass_descriptor_queue_},
+      compute_pass_descriptor_queue{compute_pass_descriptor_queue_}, memory_allocator{
-      memory_allocator{memory_allocator_} {}
+                                                                         memory_allocator_} {}
 
 ASTCDecoderPass::~ASTCDecoderPass() = default;
 

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -31,8 +31,8 @@ ComputePipeline::ComputePipeline(const Device& device_, vk::PipelineCache& pipel
                                  PipelineStatistics* pipeline_statistics,
                                  VideoCore::ShaderNotify* shader_notify, const Shader::Info& info_,
                                  vk::ShaderModule spv_module_)
-    : device{device_}, pipeline_cache(pipeline_cache_),
+    : device{device_},
-      guest_descriptor_queue{guest_descriptor_queue_}, info{info_},
+      pipeline_cache(pipeline_cache_), guest_descriptor_queue{guest_descriptor_queue_}, info{info_},
       spv_module(std::move(spv_module_)) {
     if (shader_notify) {
         shader_notify->MarkShaderBuilding();

src/video_core/renderer_vulkan/vk_present_manager.cpp

@@ -100,8 +100,8 @@ PresentManager::PresentManager(const vk::Instance& instance_,
                                Swapchain& swapchain_, vk::SurfaceKHR& surface_)
     : instance{instance_}, render_window{render_window_}, device{device_},
       memory_allocator{memory_allocator_}, scheduler{scheduler_}, swapchain{swapchain_},
-      surface{surface_},
+      surface{surface_}, blit_supported{CanBlitToSwapchain(device.GetPhysical(),
-      blit_supported{CanBlitToSwapchain(device.GetPhysical(), swapchain.GetImageViewFormat())},
+                                                           swapchain.GetImageViewFormat())},
       use_present_thread{Settings::values.async_presentation.GetValue()} {
     SetImageCount();
 

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -1161,9 +1161,10 @@ struct QueryCacheRuntimeImpl {
                           StagingBufferPool& staging_pool_,
                           ComputePassDescriptorQueue& compute_pass_descriptor_queue,
                           DescriptorPool& descriptor_pool)
-        : rasterizer{rasterizer_}, device_memory{device_memory_}, buffer_cache{buffer_cache_},
+        : rasterizer{rasterizer_}, device_memory{device_memory_},
-          device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_},
+          buffer_cache{buffer_cache_}, device{device_},
-          staging_pool{staging_pool_}, guest_streamer(0, runtime),
+          memory_allocator{memory_allocator_}, scheduler{scheduler_}, staging_pool{staging_pool_},
+          guest_streamer(0, runtime),
           sample_streamer(static_cast<size_t>(QueryType::ZPassPixelCount64), runtime, rasterizer,
                           device, scheduler, memory_allocator, compute_pass_descriptor_queue,
                           descriptor_pool),

src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp

@@ -49,8 +49,8 @@ size_t GetStreamBufferSize(const Device& device) {
 StagingBufferPool::StagingBufferPool(const Device& device_, MemoryAllocator& memory_allocator_,
                                      Scheduler& scheduler_)
     : device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_},
-      stream_buffer_size{GetStreamBufferSize(device)},
+      stream_buffer_size{GetStreamBufferSize(device)}, region_size{stream_buffer_size /
-      region_size{stream_buffer_size / StagingBufferPool::NUM_SYNCS} {
+                                                                   StagingBufferPool::NUM_SYNCS} {
     VkBufferCreateInfo stream_ci = {
         .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
         .pNext = nullptr,

src/video_core/shader_environment.cpp

@@ -398,8 +398,8 @@ u32 GraphicsEnvironment::ReadViewportTransformState() {
 ComputeEnvironment::ComputeEnvironment(Tegra::Engines::KeplerCompute& kepler_compute_,
                                        Tegra::MemoryManager& gpu_memory_, GPUVAddr program_base_,
                                        u32 start_address_)
-    : GenericEnvironment{gpu_memory_, program_base_, start_address_},
+    : GenericEnvironment{gpu_memory_, program_base_, start_address_}, kepler_compute{
-      kepler_compute{&kepler_compute_} {
+                                                                          &kepler_compute_} {
     const auto& qmd{kepler_compute->launch_description};
     stage = Shader::Stage::Compute;
     local_memory_size = qmd.local_pos_alloc + qmd.local_crs_alloc;

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -625,8 +625,8 @@ class Image {
 public:
     explicit Image(VkImage handle_, VkDevice owner_, VmaAllocator allocator_,
                    VmaAllocation allocation_, const DeviceDispatch& dld_) noexcept
-        : handle{handle_}, owner{owner_}, allocator{allocator_}, allocation{allocation_},
+        : handle{handle_}, owner{owner_}, allocator{allocator_},
-          dld{&dld_} {}
+          allocation{allocation_}, dld{&dld_} {}
     Image() = default;
 
     Image(const Image&) = delete;
@@ -680,8 +680,8 @@ public:
     explicit Buffer(VkBuffer handle_, VkDevice owner_, VmaAllocator allocator_,
                     VmaAllocation allocation_, std::span<u8> mapped_, bool is_coherent_,
                     const DeviceDispatch& dld_) noexcept
-        : handle{handle_}, owner{owner_}, allocator{allocator_}, allocation{allocation_},
+        : handle{handle_}, owner{owner_}, allocator{allocator_},
-          mapped{mapped_}, is_coherent{is_coherent_}, dld{&dld_} {}
+          allocation{allocation_}, mapped{mapped_}, is_coherent{is_coherent_}, dld{&dld_} {}
     Buffer() = default;
 
     Buffer(const Buffer&) = delete;
@@ -689,8 +689,8 @@ public:
 
     Buffer(Buffer&& rhs) noexcept
         : handle{std::exchange(rhs.handle, nullptr)}, owner{rhs.owner}, allocator{rhs.allocator},
-          allocation{rhs.allocation}, mapped{rhs.mapped}, is_coherent{rhs.is_coherent},
+          allocation{rhs.allocation}, mapped{rhs.mapped},
-          dld{rhs.dld} {}
+          is_coherent{rhs.is_coherent}, dld{rhs.dld} {}
 
     Buffer& operator=(Buffer&& rhs) noexcept {
         Release();