general: Update style to clang-format-12

src/common/alignment.h

@@ -9,41 +9,48 @@
 namespace Common {
 
 template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignUp(T value, size_t size) {
+requires std::is_unsigned_v<T>
+[[nodiscard]] constexpr T AlignUp(T value, size_t size) {
     auto mod{static_cast<T>(value % size)};
     value -= mod;
     return static_cast<T>(mod == T{0} ? value : value + size);
 }
 
 template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignUpLog2(T value, size_t align_log2) {
+requires std::is_unsigned_v<T>
+[[nodiscard]] constexpr T AlignUpLog2(T value, size_t align_log2) {
     return static_cast<T>((value + ((1ULL << align_log2) - 1)) >> align_log2 << align_log2);
 }
 
 template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignDown(T value, size_t size) {
+requires std::is_unsigned_v<T>
+[[nodiscard]] constexpr T AlignDown(T value, size_t size) {
     return static_cast<T>(value - value % size);
 }
 
 template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr bool Is4KBAligned(T value) {
+requires std::is_unsigned_v<T>
+[[nodiscard]] constexpr bool Is4KBAligned(T value) {
     return (value & 0xFFF) == 0;
 }
 
 template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr bool IsWordAligned(T value) {
+requires std::is_unsigned_v<T>
+[[nodiscard]] constexpr bool IsWordAligned(T value) {
     return (value & 0b11) == 0;
 }
 
 template <typename T>
-requires std::is_integral_v<T>[[nodiscard]] constexpr bool IsAligned(T value, size_t alignment) {
+requires std::is_integral_v<T>
+[[nodiscard]] constexpr bool IsAligned(T value, size_t alignment) {
     using U = typename std::make_unsigned_t<T>;
     const U mask = static_cast<U>(alignment - 1);
     return (value & mask) == 0;
 }
 
 template <typename T, typename U>
-requires std::is_integral_v<T>[[nodiscard]] constexpr T DivideUp(T x, U y) {
+requires std::is_integral_v<T>
+[[nodiscard]] constexpr T DivideUp(T x, U y) {
     return (x + (y - 1)) / y;
 }
 

src/common/div_ceil.h

@@ -11,15 +11,15 @@ namespace Common {
 
 /// Ceiled integer division.
 template <typename N, typename D>
-requires std::is_integral_v<N>&& std::is_unsigned_v<D>[[nodiscard]] constexpr N DivCeil(N number,
+requires std::is_integral_v<N> && std::is_unsigned_v<D>
-                                                                                        D divisor) {
+[[nodiscard]] constexpr N DivCeil(N number, D divisor) {
     return static_cast<N>((static_cast<D>(number) + divisor - 1) / divisor);
 }
 
 /// Ceiled integer division with logarithmic divisor in base 2
 template <typename N, typename D>
-requires std::is_integral_v<N>&& std::is_unsigned_v<D>[[nodiscard]] constexpr N DivCeilLog2(
+requires std::is_integral_v<N> && std::is_unsigned_v<D>
-    N value, D alignment_log2) {
+[[nodiscard]] constexpr N DivCeilLog2(N value, D alignment_log2) {
     return static_cast<N>((static_cast<D>(value) + (D(1) << alignment_log2) - 1) >> alignment_log2);
 }
 

src/common/intrusive_red_black_tree.h

@@ -235,8 +235,7 @@ public:
 
 template <typename T>
 concept HasLightCompareType = requires {
-    { std::is_same<typename T::LightCompareType, void>::value }
+    { std::is_same<typename T::LightCompareType, void>::value } -> std::convertible_to<bool>;
-    ->std::convertible_to<bool>;
 };
 
 namespace impl {

src/common/vector_math.h

@@ -667,8 +667,8 @@ template <typename T>
 
 // linear interpolation via float: 0.0=begin, 1.0=end
 template <typename X>
-[[nodiscard]] constexpr decltype(X{} * float{} + X{} * float{}) Lerp(const X& begin, const X& end,
+[[nodiscard]] constexpr decltype(X{} * float{} + X{} * float{})
-                                                                     const float t) {
+    Lerp(const X& begin, const X& end, const float t) {
     return begin * (1.f - t) + end * t;
 }
 

src/core/hle/kernel/k_priority_queue.h

@@ -22,12 +22,10 @@ class KThread;
 
 template <typename T>
 concept KPriorityQueueAffinityMask = !std::is_reference_v<T> && requires(T & t) {
-    { t.GetAffinityMask() }
+    { t.GetAffinityMask() } -> Common::ConvertibleTo<u64>;
-    ->Common::ConvertibleTo<u64>;
     {t.SetAffinityMask(0)};
 
-    { t.GetAffinity(0) }
+    { t.GetAffinity(0) } -> std::same_as<bool>;
-    ->std::same_as<bool>;
     {t.SetAffinity(0, false)};
     {t.SetAll()};
 };
@@ -38,25 +36,20 @@ concept KPriorityQueueMember = !std::is_reference_v<T> && requires(T & t) {
     {(typename T::QueueEntry()).Initialize()};
     {(typename T::QueueEntry()).SetPrev(std::addressof(t))};
     {(typename T::QueueEntry()).SetNext(std::addressof(t))};
-    { (typename T::QueueEntry()).GetNext() }
+    { (typename T::QueueEntry()).GetNext() } -> std::same_as<T*>;
-    ->std::same_as<T*>;
+    { (typename T::QueueEntry()).GetPrev() } -> std::same_as<T*>;
-    { (typename T::QueueEntry()).GetPrev() }
+    { t.GetPriorityQueueEntry(0) } -> std::same_as<typename T::QueueEntry&>;
-    ->std::same_as<T*>;
-    { t.GetPriorityQueueEntry(0) }
-    ->std::same_as<typename T::QueueEntry&>;
 
     {t.GetAffinityMask()};
-    { std::remove_cvref_t<decltype(t.GetAffinityMask())>() }
+    { std::remove_cvref_t<decltype(t.GetAffinityMask())>() } -> KPriorityQueueAffinityMask;
-    ->KPriorityQueueAffinityMask;
 
-    { t.GetActiveCore() }
+    { t.GetActiveCore() } -> Common::ConvertibleTo<s32>;
-    ->Common::ConvertibleTo<s32>;
+    { t.GetPriority() } -> Common::ConvertibleTo<s32>;
-    { t.GetPriority() }
-    ->Common::ConvertibleTo<s32>;
 };
 
 template <typename Member, size_t NumCores_, int LowestPriority, int HighestPriority>
-requires KPriorityQueueMember<Member> class KPriorityQueue {
+requires KPriorityQueueMember<Member>
+class KPriorityQueue {
 public:
     using AffinityMaskType = std::remove_cv_t<
         std::remove_reference_t<decltype(std::declval<Member>().GetAffinityMask())>>;

src/core/hle/kernel/k_scoped_lock.h

@@ -13,14 +13,13 @@ namespace Kernel {
 
 template <typename T>
 concept KLockable = !std::is_reference_v<T> && requires(T & t) {
-    { t.Lock() }
+    { t.Lock() } -> std::same_as<void>;
-    ->std::same_as<void>;
+    { t.Unlock() } -> std::same_as<void>;
-    { t.Unlock() }
-    ->std::same_as<void>;
 };
 
 template <typename T>
-requires KLockable<T> class [[nodiscard]] KScopedLock {
+requires KLockable<T>
+class [[nodiscard]] KScopedLock {
 public:
     explicit KScopedLock(T* l) : lock_ptr(l) {
         this->lock_ptr->Lock();

src/input_common/main.cpp

@@ -346,8 +346,8 @@ void InputSubsystem::ReloadInputDevices() {
     impl->udp->ReloadSockets();
 }
 
-std::vector<std::unique_ptr<Polling::DevicePoller>> InputSubsystem::GetPollers([
+std::vector<std::unique_ptr<Polling::DevicePoller>> InputSubsystem::GetPollers(
-    [maybe_unused]] Polling::DeviceType type) const {
+    [[maybe_unused]] Polling::DeviceType type) const {
 #ifdef HAVE_SDL2
     return impl->sdl->GetPollers(type);
 #else

src/shader_recompiler/object_pool.h

@@ -11,14 +11,16 @@
 namespace Shader {
 
 template <typename T>
-requires std::is_destructible_v<T> class ObjectPool {
+requires std::is_destructible_v<T>
+class ObjectPool {
 public:
     explicit ObjectPool(size_t chunk_size = 8192) : new_chunk_size{chunk_size} {
         node = &chunks.emplace_back(new_chunk_size);
     }
 
     template <typename... Args>
-    requires std::is_constructible_v<T, Args...>[[nodiscard]] T* Create(Args&&... args) {
+    requires std::is_constructible_v<T, Args...>
+    [[nodiscard]] T* Create(Args&&... args) {
         return std::construct_at(Memory(), std::forward<Args>(args)...);
     }
 

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -97,19 +97,14 @@ RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
                                Core::Frontend::EmuWindow& emu_window,
                                Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
                                std::unique_ptr<Core::Frontend::GraphicsContext> context_) try
-    : RendererBase(emu_window, std::move(context_)),
+    : RendererBase(emu_window, std::move(context_)), telemetry_session(telemetry_session_),
-      telemetry_session(telemetry_session_),
+      cpu_memory(cpu_memory_), gpu(gpu_), library(OpenLibrary()),
-      cpu_memory(cpu_memory_),
-      gpu(gpu_),
-      library(OpenLibrary()),
       instance(CreateInstance(library, dld, VK_API_VERSION_1_1, render_window.GetWindowInfo().type,
                               true, Settings::values.renderer_debug.GetValue())),
       debug_callback(Settings::values.renderer_debug ? CreateDebugCallback(instance) : nullptr),
       surface(CreateSurface(instance, render_window)),
-      device(CreateDevice(instance, dld, *surface)),
+      device(CreateDevice(instance, dld, *surface)), memory_allocator(device, false),
-      memory_allocator(device, false),
+      state_tracker(gpu), scheduler(device, state_tracker),
-      state_tracker(gpu),
-      scheduler(device, state_tracker),
       swapchain(*surface, device, scheduler, render_window.GetFramebufferLayout().width,
                 render_window.GetFramebufferLayout().height, false),
       blit_screen(cpu_memory, render_window, device, memory_allocator, swapchain, scheduler,

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -508,7 +508,8 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
                 .location = static_cast<u32>(index),
                 .binding = 0,
                 .format = type == 1   ? VK_FORMAT_R32_SFLOAT
-                                    : type == 2 ? VK_FORMAT_R32_SINT : VK_FORMAT_R32_UINT,
+                          : type == 2 ? VK_FORMAT_R32_SINT
+                                      : VK_FORMAT_R32_UINT,
                 .offset = 0,
             });
         }

src/video_core/texture_cache/slot_vector.h

@@ -31,8 +31,8 @@ struct SlotId {
 };
 
 template <class T>
-requires std::is_nothrow_move_assignable_v<T>&&
+requires std::is_nothrow_move_assignable_v<T> && std::is_nothrow_move_constructible_v<T>
-    std::is_nothrow_move_constructible_v<T> class SlotVector {
+class SlotVector {
 public:
     class Iterator {
         friend SlotVector<T>;