linter: Apply clang-format 19.1 formatting

find ./Source/ -name '*.cpp' -o -name '*.h' | xargs clang-format-19 -i

Source/Core/Common/Assembler/AssemblerTables.cpp

@@ -429,7 +429,10 @@ extern const CaseInsensitiveDict<ParseInfo, '.', '_'> mnemonic_tokens = {
 
 #define PSEUDO(mnemonic, base, variant_bits, alg)                                                  \
   {                                                                                                \
-    mnemonic, { static_cast<size_t>(base) * VARIANT_PERMUTATIONS + (variant_bits), alg }           \
+    mnemonic,                                                                                      \
+    {                                                                                              \
+      static_cast<size_t>(base) * VARIANT_PERMUTATIONS + (variant_bits), alg                       \
+    }                                                                                              \
   }
 #define PLAIN_PSEUDO(mnemonic, base, alg) PSEUDO(mnemonic, base, PLAIN_MNEMONIC, alg)
 #define RC_PSEUDO(mnemonic, base, alg)                                                             \
@@ -1048,7 +1051,10 @@ void FillMfsprBatAndBitswap(OperandList& operands)
 }  // namespace
 
 #define PSEUDO(base, variant_bits, cb)                                                             \
-  ExtendedMnemonicDesc { static_cast<size_t>(base) * VARIANT_PERMUTATIONS + variant_bits, cb }
+  ExtendedMnemonicDesc                                                                             \
+  {                                                                                                \
+    static_cast<size_t>(base) * VARIANT_PERMUTATIONS + variant_bits, cb                            \
+  }
 #define PLAIN_PSEUDO(base, cb)                                                                     \
   PSEUDO(base, PLAIN_MNEMONIC, cb), INVALID_EXT_MNEMONIC, INVALID_EXT_MNEMONIC, INVALID_EXT_MNEMONIC
 #define RC_PSEUDO(base, cb)                                                                        \

Source/Core/Common/CompatPatches.cpp

@@ -155,6 +155,6 @@ int __cdecl EnableCompatPatches()
 // referencing it doesn't require ugly decorated names.
 // Use /include:enableCompatPatches linker flag to enable this.
 extern "C" {
-__declspec(allocate(".CRT$XCZ")) decltype(&EnableCompatPatches)
-    enableCompatPatches = EnableCompatPatches;
+__declspec(allocate(".CRT$XCZ")) decltype(&EnableCompatPatches) enableCompatPatches =
+    EnableCompatPatches;
 }

Source/Core/Common/Contains.h

@@ -12,15 +12,16 @@ struct ContainsFn
 {
   template <std::input_iterator I, std::sentinel_for<I> S, class T, class Proj = std::identity>
     requires std::indirect_binary_predicate<std::ranges::equal_to, std::projected<I, Proj>,
-  const T* > constexpr bool operator()(I first, S last, const T& value, Proj proj = {}) const
+                                            const T*>
+  constexpr bool operator()(I first, S last, const T& value, Proj proj = {}) const
   {
     return std::ranges::find(std::move(first), last, value, std::move(proj)) != last;
   }
 
   template <std::ranges::input_range R, class T, class Proj = std::identity>
-  requires std::indirect_binary_predicate < std::ranges::equal_to,
-      std::projected<std::ranges::iterator_t<R>, Proj>,
-  const T* > constexpr bool operator()(R&& r, const T& value, Proj proj = {}) const
+    requires std::indirect_binary_predicate<
+        std::ranges::equal_to, std::projected<std::ranges::iterator_t<R>, Proj>, const T*>
+  constexpr bool operator()(R&& r, const T& value, Proj proj = {}) const
   {
     return (*this)(std::ranges::begin(r), std::ranges::end(r), value, std::move(proj));
   }

Source/Core/Common/GL/GLExtensions/GLExtensions.cpp

@@ -996,41 +996,23 @@ PFNDOLDISPATCHCOMPUTEPROC dolDispatchCompute;
 PFNDOLDISPATCHCOMPUTEINDIRECTPROC dolDispatchComputeIndirect;
 
 // Creates a GLFunc object that requires a feature
-#define GLFUNC_REQUIRES(x, y)                                                                      \
-  {                                                                                                \
-    (void**)&x, #x, y                                                                              \
-  }
+#define GLFUNC_REQUIRES(x, y) {(void**)&x, #x, y}
 // Creates a GLFunc object with a different function suffix
 // For when we want to use the same function pointer, but different function name
-#define GLFUNC_SUFFIX(x, y, z)                                                                     \
-  {                                                                                                \
-    (void**)&x, #x #y, z                                                                           \
-  }
+#define GLFUNC_SUFFIX(x, y, z) {(void**)&x, #x #y, z}
 // Creates a GLFunc object that should always be able to get grabbed
 // Used for Desktop OpenGL functions that should /always/ be provided.
 // aka GL 1.1/1.2/1.3/1.4
-#define GLFUNC_ALWAYS_REQUIRED(x)                                                                  \
-  {                                                                                                \
-    (void**)&x, #x, "VERSION_GL"                                                                   \
-  }
+#define GLFUNC_ALWAYS_REQUIRED(x) {(void**)&x, #x, "VERSION_GL"}
 // Creates a GLFunc object that should be able to get grabbed
 // on both GL and ES
-#define GL_ES_FUNC_ALWAYS_REQUIRED(x)                                                              \
-  {                                                                                                \
-    (void**)&x, #x, "VERSION_GL |VERSION_GLES_2"                                                   \
-  }
+#define GL_ES_FUNC_ALWAYS_REQUIRED(x) {(void**)&x, #x, "VERSION_GL |VERSION_GLES_2"}
 // Creates a GLFunc object that should be able to get grabbed
 // on both GL and ES 3.0
-#define GL_ES3_FUNC_ALWAYS_REQUIRED(x)                                                             \
-  {                                                                                                \
-    (void**)&x, #x, "VERSION_GL |VERSION_GLES_3"                                                   \
-  }
+#define GL_ES3_FUNC_ALWAYS_REQUIRED(x) {(void**)&x, #x, "VERSION_GL |VERSION_GLES_3"}
 // Creates a GLFunc object that should be able to get grabbed
 // on both GL and ES 3.2
-#define GL_ES32_FUNC_ALWAYS_REQUIRED(x)                                                            \
-  {                                                                                                \
-    (void**)&x, #x, "VERSION_GL |VERSION_GLES_3_2"                                                 \
-  }
+#define GL_ES32_FUNC_ALWAYS_REQUIRED(x) {(void**)&x, #x, "VERSION_GL |VERSION_GLES_3_2"}
 
 struct GLFunc
 {

Source/Core/Common/StringUtil.h

@@ -73,9 +73,8 @@ void TruncateToCString(std::string* s);
 bool TryParse(const std::string& str, bool* output);
 
 template <typename T>
-requires(std::is_integral_v<T> ||
-         (std::is_enum_v<T> && !detail::IsBooleanEnum<T>())) bool TryParse(const std::string& str,
-                                                                           T* output, int base = 0)
+  requires(std::is_integral_v<T> || (std::is_enum_v<T> && !detail::IsBooleanEnum<T>()))
+bool TryParse(const std::string& str, T* output, int base = 0)
 {
   char* end_ptr = nullptr;
 
@@ -113,7 +112,8 @@ requires(std::is_integral_v<T> ||
 }
 
 template <typename T>
-requires(detail::IsBooleanEnum<T>()) bool TryParse(const std::string& str, T* output)
+  requires(detail::IsBooleanEnum<T>())
+bool TryParse(const std::string& str, T* output)
 {
   bool value;
   if (!TryParse(str, &value))

Source/Core/Core/HW/DSPHLE/UCodes/Zelda.cpp

@@ -672,7 +672,10 @@ void ZeldaUCode::RenderAudio()
 // Utility to define 32 bit accessors/modifiers methods based on two 16 bit
 // fields named _l and _h.
 #define DEFINE_32BIT_ACCESSOR(field_name, name)                                                    \
-  u32 Get##name() const { return (field_name##_h << 16) | field_name##_l; }                        \
+  u32 Get##name() const                                                                            \
+  {                                                                                                \
+    return (field_name##_h << 16) | field_name##_l;                                                \
+  }                                                                                                \
   void Set##name(u32 v)                                                                            \
   {                                                                                                \
     field_name##_h = v >> 16;                                                                      \

Source/Core/Core/IOS/USB/USB_KBD.cpp

@@ -177,8 +177,8 @@ constexpr std::array<u8, 256> s_key_codes_azerty{};
 }  // Anonymous namespace
 
 USB_KBD::MessageData::MessageData(MessageType type, u8 modifiers_, PressedKeyData pressed_keys_)
-    : msg_type{Common::swap32(static_cast<u32>(type))}, modifiers{modifiers_}, pressed_keys{
-                                                                                   pressed_keys_}
+    : msg_type{Common::swap32(static_cast<u32>(type))}, modifiers{modifiers_},
+      pressed_keys{pressed_keys_}
 {
 }
 

Source/Core/Core/PowerPC/Expression.cpp

@@ -230,8 +230,7 @@ Expression::Expression(std::string_view text, ExprPointer ex, ExprVarListPointer
     : m_text(text), m_expr(std::move(ex)), m_vars(std::move(vars))
 {
   using LookupKV = std::pair<std::string_view, Expression::VarBinding>;
-  static constexpr auto sorted_lookup = []() consteval
-  {
+  static constexpr auto sorted_lookup = []() consteval {
     using enum Expression::VarBindingType;
     auto unsorted_lookup = std::to_array<LookupKV>({
         {"r0", {GPR, 0}},
@@ -385,8 +384,7 @@ Expression::Expression(std::string_view text, ExprPointer ex, ExprVarListPointer
     });
     std::ranges::sort(unsorted_lookup, {}, &LookupKV::first);
     return unsorted_lookup;
-  }
-  ();
+  }();
   static_assert(std::ranges::adjacent_find(sorted_lookup, {}, &LookupKV::first) ==
                     sorted_lookup.end(),
                 "Expression: Sorted lookup should not contain duplicate keys.");

Source/Core/Core/PowerPC/Interpreter/Interpreter_Tables.cpp

@@ -337,8 +337,7 @@ constexpr std::array<InterpreterOpTemplate, 10> s_table63_2{{
     {31, Interpreter::fnmaddx},   // fnmaddx
 }};
 
-constexpr std::array<Interpreter::Instruction, 64> s_interpreter_op_table = []() consteval
-{
+constexpr std::array<Interpreter::Instruction, 64> s_interpreter_op_table = []() consteval {
   std::array<Interpreter::Instruction, 64> table{};
   table.fill(Interpreter::unknown_instruction);
   for (auto& tpl : s_primary_table)
@@ -347,10 +346,8 @@ constexpr std::array<Interpreter::Instruction, 64> s_interpreter_op_table = []()
     table[tpl.opcode] = tpl.fn;
   };
   return table;
-}
-();
-constexpr std::array<Interpreter::Instruction, 1024> s_interpreter_op_table4 = []() consteval
-{
+}();
+constexpr std::array<Interpreter::Instruction, 1024> s_interpreter_op_table4 = []() consteval {
   std::array<Interpreter::Instruction, 1024> table{};
   table.fill(Interpreter::unknown_instruction);
 
@@ -384,10 +381,8 @@ constexpr std::array<Interpreter::Instruction, 1024> s_interpreter_op_table4 = [
   }
 
   return table;
-}
-();
-constexpr std::array<Interpreter::Instruction, 1024> s_interpreter_op_table19 = []() consteval
-{
+}();
+constexpr std::array<Interpreter::Instruction, 1024> s_interpreter_op_table19 = []() consteval {
   std::array<Interpreter::Instruction, 1024> table{};
   table.fill(Interpreter::unknown_instruction);
   for (auto& tpl : s_table19)
@@ -396,10 +391,8 @@ constexpr std::array<Interpreter::Instruction, 1024> s_interpreter_op_table19 =
     table[tpl.opcode] = tpl.fn;
   };
   return table;
-}
-();
-constexpr std::array<Interpreter::Instruction, 1024> s_interpreter_op_table31 = []() consteval
-{
+}();
+constexpr std::array<Interpreter::Instruction, 1024> s_interpreter_op_table31 = []() consteval {
   std::array<Interpreter::Instruction, 1024> table{};
   table.fill(Interpreter::unknown_instruction);
   for (auto& tpl : s_table31)
@@ -408,10 +401,8 @@ constexpr std::array<Interpreter::Instruction, 1024> s_interpreter_op_table31 =
     table[tpl.opcode] = tpl.fn;
   };
   return table;
-}
-();
-constexpr std::array<Interpreter::Instruction, 32> s_interpreter_op_table59 = []() consteval
-{
+}();
+constexpr std::array<Interpreter::Instruction, 32> s_interpreter_op_table59 = []() consteval {
   std::array<Interpreter::Instruction, 32> table{};
   table.fill(Interpreter::unknown_instruction);
   for (auto& tpl : s_table59)
@@ -420,10 +411,8 @@ constexpr std::array<Interpreter::Instruction, 32> s_interpreter_op_table59 = []
     table[tpl.opcode] = tpl.fn;
   };
   return table;
-}
-();
-constexpr std::array<Interpreter::Instruction, 1024> s_interpreter_op_table63 = []() consteval
-{
+}();
+constexpr std::array<Interpreter::Instruction, 1024> s_interpreter_op_table63 = []() consteval {
   std::array<Interpreter::Instruction, 1024> table{};
   table.fill(Interpreter::unknown_instruction);
   for (auto& tpl : s_table63)
@@ -444,8 +433,7 @@ constexpr std::array<Interpreter::Instruction, 1024> s_interpreter_op_table63 =
   }
 
   return table;
-}
-();
+}();
 
 Interpreter::Instruction Interpreter::GetInterpreterOp(UGeckoInstruction inst)
 {

Source/Core/Core/PowerPC/Jit64/Jit64_Tables.cpp

@@ -335,8 +335,7 @@ constexpr std::array<Jit64OpTemplate, 10> s_table63_2{{
     {31, &Jit64::fmaddXX},   // fnmaddx
 }};
 
-constexpr std::array<Jit64::Instruction, 64> s_dyna_op_table = []() consteval
-{
+constexpr std::array<Jit64::Instruction, 64> s_dyna_op_table = []() consteval {
   std::array<Jit64::Instruction, 64> table{};
   table.fill(&Jit64::FallBackToInterpreter);
 
@@ -347,11 +346,9 @@ constexpr std::array<Jit64::Instruction, 64> s_dyna_op_table = []() consteval
   }
 
   return table;
-}
-();
+}();
 
-constexpr std::array<Jit64::Instruction, 1024> s_dyna_op_table4 = []() consteval
-{
+constexpr std::array<Jit64::Instruction, 1024> s_dyna_op_table4 = []() consteval {
   std::array<Jit64::Instruction, 1024> table{};
   table.fill(&Jit64::FallBackToInterpreter);
 
@@ -385,11 +382,9 @@ constexpr std::array<Jit64::Instruction, 1024> s_dyna_op_table4 = []() consteval
   }
 
   return table;
-}
-();
+}();
 
-constexpr std::array<Jit64::Instruction, 1024> s_dyna_op_table19 = []() consteval
-{
+constexpr std::array<Jit64::Instruction, 1024> s_dyna_op_table19 = []() consteval {
   std::array<Jit64::Instruction, 1024> table{};
   table.fill(&Jit64::FallBackToInterpreter);
 
@@ -400,11 +395,9 @@ constexpr std::array<Jit64::Instruction, 1024> s_dyna_op_table19 = []() consteva
   }
 
   return table;
-}
-();
+}();
 
-constexpr std::array<Jit64::Instruction, 1024> s_dyna_op_table31 = []() consteval
-{
+constexpr std::array<Jit64::Instruction, 1024> s_dyna_op_table31 = []() consteval {
   std::array<Jit64::Instruction, 1024> table{};
   table.fill(&Jit64::FallBackToInterpreter);
 
@@ -415,11 +408,9 @@ constexpr std::array<Jit64::Instruction, 1024> s_dyna_op_table31 = []() consteva
   }
 
   return table;
-}
-();
+}();
 
-constexpr std::array<Jit64::Instruction, 32> s_dyna_op_table59 = []() consteval
-{
+constexpr std::array<Jit64::Instruction, 32> s_dyna_op_table59 = []() consteval {
   std::array<Jit64::Instruction, 32> table{};
   table.fill(&Jit64::FallBackToInterpreter);
 
@@ -430,11 +421,9 @@ constexpr std::array<Jit64::Instruction, 32> s_dyna_op_table59 = []() consteval
   }
 
   return table;
-}
-();
+}();
 
-constexpr std::array<Jit64::Instruction, 1024> s_dyna_op_table63 = []() consteval
-{
+constexpr std::array<Jit64::Instruction, 1024> s_dyna_op_table63 = []() consteval {
   std::array<Jit64::Instruction, 1024> table{};
   table.fill(&Jit64::FallBackToInterpreter);
 
@@ -456,8 +445,7 @@ constexpr std::array<Jit64::Instruction, 1024> s_dyna_op_table63 = []() consteva
   }
 
   return table;
-}
-();
+}();
 
 }  // Anonymous namespace
 

Source/Core/Core/PowerPC/JitArm64/JitArm64_Tables.cpp

@@ -335,8 +335,7 @@ constexpr std::array<JitArm64OpTemplate, 10> s_table63_2{{
     {31, &JitArm64::fp_arith},  // fnmaddx
 }};
 
-constexpr std::array<JitArm64::Instruction, 64> s_dyna_op_table = []() consteval
-{
+constexpr std::array<JitArm64::Instruction, 64> s_dyna_op_table = []() consteval {
   std::array<JitArm64::Instruction, 64> table{};
   table.fill(&JitArm64::FallBackToInterpreter);
 
@@ -347,11 +346,9 @@ constexpr std::array<JitArm64::Instruction, 64> s_dyna_op_table = []() consteval
   }
 
   return table;
-}
-();
+}();
 
-constexpr std::array<JitArm64::Instruction, 1024> s_dyna_op_table4 = []() consteval
-{
+constexpr std::array<JitArm64::Instruction, 1024> s_dyna_op_table4 = []() consteval {
   std::array<JitArm64::Instruction, 1024> table{};
   table.fill(&JitArm64::FallBackToInterpreter);
 
@@ -385,11 +382,9 @@ constexpr std::array<JitArm64::Instruction, 1024> s_dyna_op_table4 = []() conste
   }
 
   return table;
-}
-();
+}();
 
-constexpr std::array<JitArm64::Instruction, 1024> s_dyna_op_table19 = []() consteval
-{
+constexpr std::array<JitArm64::Instruction, 1024> s_dyna_op_table19 = []() consteval {
   std::array<JitArm64::Instruction, 1024> table{};
   table.fill(&JitArm64::FallBackToInterpreter);
 
@@ -400,11 +395,9 @@ constexpr std::array<JitArm64::Instruction, 1024> s_dyna_op_table19 = []() const
   }
 
   return table;
-}
-();
+}();
 
-constexpr std::array<JitArm64::Instruction, 1024> s_dyna_op_table31 = []() consteval
-{
+constexpr std::array<JitArm64::Instruction, 1024> s_dyna_op_table31 = []() consteval {
   std::array<JitArm64::Instruction, 1024> table{};
   table.fill(&JitArm64::FallBackToInterpreter);
 
@@ -415,11 +408,9 @@ constexpr std::array<JitArm64::Instruction, 1024> s_dyna_op_table31 = []() const
   }
 
   return table;
-}
-();
+}();
 
-constexpr std::array<JitArm64::Instruction, 32> s_dyna_op_table59 = []() consteval
-{
+constexpr std::array<JitArm64::Instruction, 32> s_dyna_op_table59 = []() consteval {
   std::array<JitArm64::Instruction, 32> table{};
   table.fill(&JitArm64::FallBackToInterpreter);
 
@@ -430,11 +421,9 @@ constexpr std::array<JitArm64::Instruction, 32> s_dyna_op_table59 = []() constev
   }
 
   return table;
-}
-();
+}();
 
-constexpr std::array<JitArm64::Instruction, 1024> s_dyna_op_table63 = []() consteval
-{
+constexpr std::array<JitArm64::Instruction, 1024> s_dyna_op_table63 = []() consteval {
   std::array<JitArm64::Instruction, 1024> table{};
   table.fill(&JitArm64::FallBackToInterpreter);
 
@@ -456,8 +445,7 @@ constexpr std::array<JitArm64::Instruction, 1024> s_dyna_op_table63 = []() const
   }
 
   return table;
-}
-();
+}();
 
 }  // Anonymous namespace
 

Source/Core/Core/PowerPC/PPCTables.cpp

@@ -507,13 +507,11 @@ struct Tables
 
 static std::array<GekkoOPStats, TOTAL_INSTRUCTION_COUNT> s_all_instructions_stats;
 
-constexpr Tables s_tables = []() consteval
-{
+constexpr Tables s_tables = []() consteval {
   Tables tables{};
 
   u32 counter = 0;
-  auto make_info = [&](const GekkoOPTemplate& inst) consteval->u32
-  {
+  auto make_info = [&](const GekkoOPTemplate& inst) consteval -> u32 {
     ASSERT(counter < TOTAL_INSTRUCTION_COUNT);
     GekkoOPInfo* info = &tables.all_instructions[counter];
     info->opname = inst.opname;
@@ -609,8 +607,7 @@ constexpr Tables s_tables = []() consteval
 
   ASSERT(counter == TOTAL_INSTRUCTION_COUNT);
   return tables;
-}
-();
+}();
 
 const GekkoOPInfo* GetOpInfo(UGeckoInstruction inst, u32 pc)
 {

Source/Core/DolphinNoGUI/MainNoGUI.cpp

@@ -209,8 +209,7 @@ int main(int argc, char* argv[])
   parser->add_option("-p", "--platform")
       .action("store")
       .help("Window platform to use [%choices]")
-      .choices({
-        "headless"
+      .choices({"headless"
 #ifdef __linux__
                 ,
                 "fbdev"

Source/Core/DolphinQt/GameList/GameTracker.cpp

@@ -51,9 +51,8 @@ GameTracker::GameTracker(QObject* parent) : QFileSystemWatcher(parent)
     }
   });
 
-  connect(&Settings::Instance(), &Settings::MetadataRefreshRequested, this, [this] {
-    m_load_thread.EmplaceItem(Command{CommandType::UpdateMetadata, {}});
-  });
+  connect(&Settings::Instance(), &Settings::MetadataRefreshRequested, this,
+          [this] { m_load_thread.EmplaceItem(Command{CommandType::UpdateMetadata, {}}); });
 
   m_load_thread.Reset("GameList Tracker", [this](Command command) {
     switch (command.type)

Source/Core/VideoBackends/Software/TextureEncoder.cpp

@@ -906,7 +906,10 @@ static void EncodeRGB8(u8* dst, const u8* src, EFBCopyFormat format, bool yuv)
   case EFBCopyFormat::A8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS { *dst++ = 0xff; }
+    ENCODE_LOOP_BLOCKS
+    {
+      *dst++ = 0xff;
+    }
     ENCODE_LOOP_SPANS
     break;
 
@@ -1135,7 +1138,10 @@ static void EncodeRGB8halfscale(u8* dst, const u8* src, EFBCopyFormat format, bo
   case EFBCopyFormat::A8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS { *dst++ = 0xff; }
+    ENCODE_LOOP_BLOCKS
+    {
+      *dst++ = 0xff;
+    }
     ENCODE_LOOP_SPANS
     break;
 

Source/Core/VideoCommon/VertexLoaderBase.h

@@ -73,9 +73,9 @@ public:
 
 protected:
   VertexLoaderBase(const TVtxDesc& vtx_desc, const VAT& vtx_attr)
-      : m_vertex_size{GetVertexSize(vtx_desc, vtx_attr)}, m_native_components{GetVertexComponents(
-                                                              vtx_desc, vtx_attr)},
-        m_VtxAttr{vtx_attr}, m_VtxDesc{vtx_desc}
+      : m_vertex_size{GetVertexSize(vtx_desc, vtx_attr)},
+        m_native_components{GetVertexComponents(vtx_desc, vtx_attr)}, m_VtxAttr{vtx_attr},
+        m_VtxDesc{vtx_desc}
   {
   }
 

Source/Core/VideoCommon/VertexLoader_Color.h

@@ -34,8 +34,7 @@ private:
 
   using SizeTable = EnumMap<EnumMap<u32, ColorFormat::RGBA8888>, VertexComponentFormat::Index16>;
 
-  static constexpr SizeTable s_table_size = []() consteval
-  {
+  static constexpr SizeTable s_table_size = []() consteval {
     SizeTable table{};
 
     using VCF = VertexComponentFormat;
@@ -45,6 +44,5 @@ private:
     table[VCF::Index16] = {2u, 2u, 2u, 2u, 2u, 2u};
 
     return table;
-  }
-  ();
+  }();
 };

Source/Core/VideoCommon/VertexLoader_Normal.h

@@ -31,8 +31,7 @@ private:
                  2>,
       VertexComponentFormat::Index16>;
 
-  static constexpr SizeTable s_table_size = []() consteval
-  {
+  static constexpr SizeTable s_table_size = []() consteval {
     SizeTable table{};
 
     using VCF = VertexComponentFormat;
@@ -145,6 +144,5 @@ private:
     table[VCF::Index16][true][NCC::NTB][FMT::InvalidFloat7] = 6;
 
     return table;
-  }
-  ();
+  }();
 };

Source/Core/VideoCommon/VertexLoader_Position.h

@@ -30,8 +30,7 @@ private:
       EnumMap<EnumMap<EnumMap<u32, CoordComponentCount::XYZ>, ComponentFormat::InvalidFloat7>,
               VertexComponentFormat::Index16>;
 
-  static constexpr SizeTable s_table_size = []() consteval
-  {
+  static constexpr SizeTable s_table_size = []() consteval {
     SizeTable table{};
 
     using VCF = VertexComponentFormat;
@@ -65,6 +64,5 @@ private:
     table[VCF::Index16][FMT::InvalidFloat7] = {2, 2};
 
     return table;
-  }
-  ();
+  }();
 };

Source/Core/VideoCommon/VertexLoader_TextCoord.h

@@ -33,8 +33,7 @@ private:
       EnumMap<EnumMap<EnumMap<u32, TexComponentCount::ST>, ComponentFormat::InvalidFloat7>,
               VertexComponentFormat::Index16>;
 
-  static constexpr SizeTable s_table_size = []() consteval
-  {
+  static constexpr SizeTable s_table_size = []() consteval {
     SizeTable table{};
 
     using VCF = VertexComponentFormat;
@@ -68,6 +67,5 @@ private:
     table[VCF::Index16][FMT::InvalidFloat7] = {2, 2};
 
     return table;
-  }
-  ();
+  }();
 };