9 files changed, 47 insertions, 56 deletions

diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 055bea641..113e663b5 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -774,19 +774,15 @@ if (MSVC)
         /we4244 # 'conversion': conversion from 'type1' to 'type2', possible loss of data
         /we4245 # 'conversion': conversion from 'type1' to 'type2', signed/unsigned mismatch
         /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
+        /we4800 # Implicit conversion from 'type' to bool. Possible information loss
     )
 else()
     target_compile_options(core PRIVATE
         -Werror=conversion
-        -Werror=ignored-qualifiers
 
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=class-memaccess>
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
+        -Wno-sign-conversion
 
         $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
-
-        -Wno-sign-conversion
     )
 endif()
 
diff --git a/src/core/file_sys/card_image.cpp b/src/core/file_sys/card_image.cpp
index f23d9373b..5d02865f4 100644
--- a/src/core/file_sys/card_image.cpp
+++ b/src/core/file_sys/card_image.cpp
@@ -232,8 +232,8 @@ const std::vector<std::shared_ptr<NCA>>& XCI::GetNCAs() const {
 
 std::shared_ptr<NCA> XCI::GetNCAByType(NCAContentType type) const {
     const auto program_id = secure_partition->GetProgramTitleID();
-    const auto iter = std::find_if(
-        ncas.begin(), ncas.end(), [this, type, program_id](const std::shared_ptr<NCA>& nca) {
+    const auto iter =
+        std::find_if(ncas.begin(), ncas.end(), [type, program_id](const std::shared_ptr<NCA>& nca) {
             return nca->GetType() == type && nca->GetTitleId() == program_id;
         });
     return iter == ncas.end() ? nullptr : *iter;
diff --git a/src/core/file_sys/program_metadata.cpp b/src/core/file_sys/program_metadata.cpp
index 08d489eab..f00479bd3 100644
--- a/src/core/file_sys/program_metadata.cpp
+++ b/src/core/file_sys/program_metadata.cpp
@@ -127,7 +127,7 @@ void ProgramMetadata::LoadManual(bool is_64_bit, ProgramAddressSpaceType address
 }
 
 bool ProgramMetadata::Is64BitProgram() const {
-    return npdm_header.has_64_bit_instructions;
+    return npdm_header.has_64_bit_instructions.As<bool>();
 }
 
 ProgramAddressSpaceType ProgramMetadata::GetAddressSpaceType() const {
diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index 025f1c78e..57eff72fe 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -1158,27 +1158,27 @@ bool EmulatedController::IsControllerSupported(bool use_temporary_value) const {
     const auto type = is_configuring && use_temporary_value ? tmp_npad_type : npad_type;
     switch (type) {
     case NpadStyleIndex::ProController:
-        return supported_style_tag.fullkey;
+        return supported_style_tag.fullkey.As<bool>();
     case NpadStyleIndex::Handheld:
-        return supported_style_tag.handheld;
+        return supported_style_tag.handheld.As<bool>();
     case NpadStyleIndex::JoyconDual:
-        return supported_style_tag.joycon_dual;
+        return supported_style_tag.joycon_dual.As<bool>();
     case NpadStyleIndex::JoyconLeft:
-        return supported_style_tag.joycon_left;
+        return supported_style_tag.joycon_left.As<bool>();
     case NpadStyleIndex::JoyconRight:
-        return supported_style_tag.joycon_right;
+        return supported_style_tag.joycon_right.As<bool>();
     case NpadStyleIndex::GameCube:
-        return supported_style_tag.gamecube;
+        return supported_style_tag.gamecube.As<bool>();
     case NpadStyleIndex::Pokeball:
-        return supported_style_tag.palma;
+        return supported_style_tag.palma.As<bool>();
     case NpadStyleIndex::NES:
-        return supported_style_tag.lark;
+        return supported_style_tag.lark.As<bool>();
     case NpadStyleIndex::SNES:
-        return supported_style_tag.lucia;
+        return supported_style_tag.lucia.As<bool>();
     case NpadStyleIndex::N64:
-        return supported_style_tag.lagoon;
+        return supported_style_tag.lagoon.As<bool>();
     case NpadStyleIndex::SegaGenesis:
-        return supported_style_tag.lager;
+        return supported_style_tag.lager.As<bool>();
     default:
         return false;
     }
diff --git a/src/core/hle/ipc_helpers.h b/src/core/hle/ipc_helpers.h
index aa27be767..18fde8bd6 100644
--- a/src/core/hle/ipc_helpers.h
+++ b/src/core/hle/ipc_helpers.h
@@ -406,7 +406,7 @@ inline s32 RequestParser::Pop() {
 }
 
 // Ignore the -Wclass-memaccess warning on memcpy for non-trivially default constructible objects.
-#if defined(__GNUC__)
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wclass-memaccess"
 #endif
@@ -417,7 +417,7 @@ void RequestParser::PopRaw(T& value) {
     std::memcpy(&value, cmdbuf + index, sizeof(T));
     index += (sizeof(T) + 3) / 4; // round up to word length
 }
-#if defined(__GNUC__)
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
 #pragma GCC diagnostic pop
 #endif
 
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index b07ae3f02..4aca5b27d 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -751,8 +751,8 @@ static void Break(Core::System& system, u32 reason, u64 info1, u64 info2) {
     }
 
     system.GetReporter().SaveSvcBreakReport(
-        static_cast<u32>(break_reason.break_type.Value()), break_reason.signal_debugger, info1,
-        info2, has_dumped_buffer ? std::make_optional(debug_buffer) : std::nullopt);
+        static_cast<u32>(break_reason.break_type.Value()), break_reason.signal_debugger.As<bool>(),
+        info1, info2, has_dumped_buffer ? std::make_optional(debug_buffer) : std::nullopt);
 
     if (!break_reason.signal_debugger) {
         LOG_CRITICAL(
diff --git a/src/core/hle/service/am/applets/applets.h b/src/core/hle/service/am/applets/applets.h
index e78a57657..12c6a5b1a 100644
--- a/src/core/hle/service/am/applets/applets.h
+++ b/src/core/hle/service/am/applets/applets.h
@@ -164,7 +164,7 @@ protected:
         u32_le size;
         u32_le library_version;
         u32_le theme_color;
-        u8 play_startup_sound;
+        bool play_startup_sound;
         u64_le system_tick;
     };
     static_assert(sizeof(CommonArguments) == 0x20, "CommonArguments has incorrect size.");
diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp
index ba8a1f786..3b26e96de 100644
--- a/src/core/hle/service/hid/controllers/npad.cpp
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@@ -1502,25 +1502,25 @@ bool Controller_NPad::IsControllerSupported(Core::HID::NpadStyleIndex controller
         Core::HID::NpadStyleTag style = GetSupportedStyleSet();
         switch (controller) {
         case Core::HID::NpadStyleIndex::ProController:
-            return style.fullkey;
+            return style.fullkey.As<bool>();
         case Core::HID::NpadStyleIndex::JoyconDual:
-            return style.joycon_dual;
+            return style.joycon_dual.As<bool>();
         case Core::HID::NpadStyleIndex::JoyconLeft:
-            return style.joycon_left;
+            return style.joycon_left.As<bool>();
         case Core::HID::NpadStyleIndex::JoyconRight:
-            return style.joycon_right;
+            return style.joycon_right.As<bool>();
         case Core::HID::NpadStyleIndex::GameCube:
-            return style.gamecube;
+            return style.gamecube.As<bool>();
         case Core::HID::NpadStyleIndex::Pokeball:
-            return style.palma;
+            return style.palma.As<bool>();
         case Core::HID::NpadStyleIndex::NES:
-            return style.lark;
+            return style.lark.As<bool>();
         case Core::HID::NpadStyleIndex::SNES:
-            return style.lucia;
+            return style.lucia.As<bool>();
         case Core::HID::NpadStyleIndex::N64:
-            return style.lagoon;
+            return style.lagoon.As<bool>();
         case Core::HID::NpadStyleIndex::SegaGenesis:
-            return style.lager;
+            return style.lager.As<bool>();
         default:
             return false;
         }
diff --git a/src/core/memory.cpp b/src/core/memory.cpp
index 9637cb5b1..3ca80c8ff 100644
--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@@ -233,18 +233,17 @@ struct Memory::Impl {
                           current_vaddr, src_addr, size);
                 std::memset(dest_buffer, 0, copy_amount);
             },
-            [&dest_buffer](const std::size_t copy_amount, const u8* const src_ptr) {
+            [&](const std::size_t copy_amount, const u8* const src_ptr) {
                 std::memcpy(dest_buffer, src_ptr, copy_amount);
             },
-            [&system = system, &dest_buffer](const VAddr current_vaddr,
-                                             const std::size_t copy_amount,
-                                             const u8* const host_ptr) {
+            [&](const VAddr current_vaddr, const std::size_t copy_amount,
+                const u8* const host_ptr) {
                 if constexpr (!UNSAFE) {
                     system.GPU().FlushRegion(current_vaddr, copy_amount);
                 }
                 std::memcpy(dest_buffer, host_ptr, copy_amount);
             },
-            [&dest_buffer](const std::size_t copy_amount) {
+            [&](const std::size_t copy_amount) {
                 dest_buffer = static_cast<u8*>(dest_buffer) + copy_amount;
             });
     }
@@ -267,17 +266,16 @@ struct Memory::Impl {
                           "Unmapped WriteBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
                           current_vaddr, dest_addr, size);
             },
-            [&src_buffer](const std::size_t copy_amount, u8* const dest_ptr) {
+            [&](const std::size_t copy_amount, u8* const dest_ptr) {
                 std::memcpy(dest_ptr, src_buffer, copy_amount);
             },
-            [&system = system, &src_buffer](const VAddr current_vaddr,
-                                            const std::size_t copy_amount, u8* const host_ptr) {
+            [&](const VAddr current_vaddr, const std::size_t copy_amount, u8* const host_ptr) {
                 if constexpr (!UNSAFE) {
                     system.GPU().InvalidateRegion(current_vaddr, copy_amount);
                 }
                 std::memcpy(host_ptr, src_buffer, copy_amount);
             },
-            [&src_buffer](const std::size_t copy_amount) {
+            [&](const std::size_t copy_amount) {
                 src_buffer = static_cast<const u8*>(src_buffer) + copy_amount;
             });
     }
@@ -301,8 +299,7 @@ struct Memory::Impl {
             [](const std::size_t copy_amount, u8* const dest_ptr) {
                 std::memset(dest_ptr, 0, copy_amount);
             },
-            [&system = system](const VAddr current_vaddr, const std::size_t copy_amount,
-                               u8* const host_ptr) {
+            [&](const VAddr current_vaddr, const std::size_t copy_amount, u8* const host_ptr) {
                 system.GPU().InvalidateRegion(current_vaddr, copy_amount);
                 std::memset(host_ptr, 0, copy_amount);
             },
@@ -313,22 +310,20 @@ struct Memory::Impl {
                    const std::size_t size) {
         WalkBlock(
             process, dest_addr, size,
-            [this, &process, &dest_addr, &src_addr, size](const std::size_t copy_amount,
-                                                          const VAddr current_vaddr) {
+            [&](const std::size_t copy_amount, const VAddr current_vaddr) {
                 LOG_ERROR(HW_Memory,
                           "Unmapped CopyBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
                           current_vaddr, src_addr, size);
                 ZeroBlock(process, dest_addr, copy_amount);
             },
-            [this, &process, &dest_addr](const std::size_t copy_amount, const u8* const src_ptr) {
+            [&](const std::size_t copy_amount, const u8* const src_ptr) {
                 WriteBlockImpl<false>(process, dest_addr, src_ptr, copy_amount);
             },
-            [this, &system = system, &process, &dest_addr](
-                const VAddr current_vaddr, const std::size_t copy_amount, u8* const host_ptr) {
+            [&](const VAddr current_vaddr, const std::size_t copy_amount, u8* const host_ptr) {
                 system.GPU().FlushRegion(current_vaddr, copy_amount);
                 WriteBlockImpl<false>(process, dest_addr, host_ptr, copy_amount);
             },
-            [&dest_addr, &src_addr](const std::size_t copy_amount) {
+            [&](const std::size_t copy_amount) {
                 dest_addr += static_cast<VAddr>(copy_amount);
                 src_addr += static_cast<VAddr>(copy_amount);
             });
@@ -575,7 +570,7 @@ struct Memory::Impl {
             [vaddr]() {
                 LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:016X}", sizeof(T) * 8, vaddr);
             },
-            [&system = system, vaddr]() { system.GPU().FlushRegion(vaddr, sizeof(T)); });
+            [&]() { system.GPU().FlushRegion(vaddr, sizeof(T)); });
         if (ptr) {
             std::memcpy(&result, ptr, sizeof(T));
         }
@@ -599,7 +594,7 @@ struct Memory::Impl {
                 LOG_ERROR(HW_Memory, "Unmapped Write{} @ 0x{:016X} = 0x{:016X}", sizeof(T) * 8,
                           vaddr, static_cast<u64>(data));
             },
-            [&system = system, vaddr]() { system.GPU().InvalidateRegion(vaddr, sizeof(T)); });
+            [&]() { system.GPU().InvalidateRegion(vaddr, sizeof(T)); });
         if (ptr) {
             std::memcpy(ptr, &data, sizeof(T));
         }
@@ -613,7 +608,7 @@ struct Memory::Impl {
                 LOG_ERROR(HW_Memory, "Unmapped WriteExclusive{} @ 0x{:016X} = 0x{:016X}",
                           sizeof(T) * 8, vaddr, static_cast<u64>(data));
             },
-            [&system = system, vaddr]() { system.GPU().InvalidateRegion(vaddr, sizeof(T)); });
+            [&]() { system.GPU().InvalidateRegion(vaddr, sizeof(T)); });
         if (ptr) {
             const auto volatile_pointer = reinterpret_cast<volatile T*>(ptr);
             return Common::AtomicCompareAndSwap(volatile_pointer, data, expected);
@@ -628,7 +623,7 @@ struct Memory::Impl {
                 LOG_ERROR(HW_Memory, "Unmapped WriteExclusive128 @ 0x{:016X} = 0x{:016X}{:016X}",
                           vaddr, static_cast<u64>(data[1]), static_cast<u64>(data[0]));
             },
-            [&system = system, vaddr]() { system.GPU().InvalidateRegion(vaddr, sizeof(u128)); });
+            [&]() { system.GPU().InvalidateRegion(vaddr, sizeof(u128)); });
         if (ptr) {
             const auto volatile_pointer = reinterpret_cast<volatile u64*>(ptr);
             return Common::AtomicCompareAndSwap(volatile_pointer, data, expected);