clean-up

Author: Neargye

.github/workflows/macos.yml

@@ -12,26 +12,28 @@ jobs:
         os:
         - macos-15 # https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md#xcode
         - macos-26 # https://github.com/actions/runner-images/blob/main/images/macos/macos-26-Readme.md#xcode
-        compiler: [Apple Clang, GCC 16]
+        compiler: [Apple Clang, GCC]
         build_type: [Release, Debug]
 
     name: "${{ matrix.os }} / ${{ matrix.compiler }} / ${{ matrix.build_type }}"
     runs-on: ${{ matrix.os }}
-    env:
-      CC: ${{ matrix.compiler == 'GCC 16' && 'gcc-16' || 'clang' }}
-      CXX: ${{ matrix.compiler == 'GCC 16' && 'g++-16' || 'clang++' }}
 
     steps:
     - uses: actions/checkout@v7
 
-    - name: Install GCC 16
-      if: ${{ matrix.compiler == 'GCC 16' }}
-      env:
-        CC: clang
-        CXX: clang++
+    - name: Configure compiler
       run: |
-        brew install gcc@16
-        echo "$(brew --prefix gcc@16)/bin" >> "${GITHUB_PATH}"
+        if [[ "${{ matrix.compiler }}" == "GCC" ]]; then
+          brew install gcc
+          gcc_bin="$(brew --prefix gcc)/bin"
+          gcc_version="$(brew list --versions gcc | awk '{print $2}')"
+          gcc_major="${gcc_version%%.*}"
+          echo "CC=${gcc_bin}/gcc-${gcc_major}" >> "${GITHUB_ENV}"
+          echo "CXX=${gcc_bin}/g++-${gcc_major}" >> "${GITHUB_ENV}"
+        else
+          echo "CC=clang" >> "${GITHUB_ENV}"
+          echo "CXX=clang++" >> "${GITHUB_ENV}"
+        fi
 
     - name: Configure
       run: cmake -S . -B build -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}

.github/workflows/windows.yml

@@ -26,5 +26,9 @@ jobs:
     - name: Build
       run: cmake --build build --parallel --config ${{ matrix.build_type }}
 
+    - name: Build C++/CLI smoke test
+      if: ${{ matrix.config.os == 'windows-2022' && matrix.platform == 'x64' && matrix.build_type == 'Release' }}
+      run: cmake --build build --target test_clr --config ${{ matrix.build_type }}
+
     - name: Test
       run: ctest --test-dir build --output-on-failure --no-tests=error -C ${{ matrix.build_type }}

include/magic_enum/magic_enum.hpp

@@ -622,11 +622,21 @@ constexpr auto MAGIC_ENUM_CALLING_CONVENTION n() noexcept {
   // CLI/C++ workaround (see https://github.com/Neargye/magic_enum/issues/284).
   str_view name;
   name.str_ = __FUNCSIG__;
-  name.size_ = sizeof(__FUNCSIG__) - 17;
-  std::size_t p = 0;
+  name.size_ = sizeof(__FUNCSIG__) - 1;
+  while (name.size_ > 0 && name.str_[name.size_ - 1] != '>') {
+    --name.size_;
+  }
+  if (name.size_ > 0) {
+    --name.size_;
+  }
+  std::size_t p = 0, depth = 0;
   for (std::size_t i = name.size_; i > 0; --i) {
-    if (name.str_[i] == ',' || name.str_[i] == ':') {
-      p = i + 1;
+    if (name.str_[i - 1] == '>') {
+      ++depth;
+    } else if (name.str_[i - 1] == '<' && depth > 0) {
+      --depth;
+    } else if (name.str_[i - 1] == ',' && depth == 0) {
+      p = i;
       break;
     }
   }
@@ -636,6 +646,14 @@ constexpr auto MAGIC_ENUM_CALLING_CONVENTION n() noexcept {
   }
   if (name.str_[0] == '(' || name.str_[0] == '-' || (name.str_[0] >= '0' && name.str_[0] <= '9')) {
     name = str_view{};
+  } else {
+    for (std::size_t i = name.size_; i > 0; --i) {
+      if (name.str_[i - 1] == ':') {
+        name.size_ -= i;
+        name.str_ += i;
+        break;
+      }
+    }
   }
   return name;
 #  endif
@@ -1059,7 +1077,7 @@ inline constexpr Hash hash_v{};
 
 template <auto* GlobValues, typename Hash>
 constexpr auto calculate_cases(std::size_t Page) noexcept {
-  constexpr std::array values = *GlobValues;
+  constexpr auto values = *GlobValues;
   constexpr std::size_t size = values.size();
 
   using switch_t = std::invoke_result_t<Hash, typename decltype(values)::value_type>;
@@ -1174,9 +1192,9 @@ constexpr decltype(auto) constexpr_switch(
   using result_t = std::invoke_result_t<ResultGetterType>;
   using hash_t = std::conditional_t<has_unique_hashes<GlobValues, Hash>(), Hash, typename Hash::secondary_hash>;
   static_assert(has_unique_hashes<GlobValues, hash_t>(), "magic_enum::detail::constexpr_switch duplicated hash found, please report it: https://github.com/Neargye/magic_enum/issues.");
-  constexpr std::array values = *GlobValues;
+  constexpr auto values = *GlobValues;
   constexpr std::size_t size = values.size();
-  constexpr std::array cases = calculate_cases<GlobValues, hash_t>(Page);
+  constexpr auto cases = calculate_cases<GlobValues, hash_t>(Page);
 
   switch (hash_v<hash_t>(searched)) {
     MAGIC_ENUM_FOR_EACH_256(MAGIC_ENUM_CASE)
@@ -1595,6 +1613,7 @@ constexpr E& operator^=(E& lhs, E rhs) noexcept {
 
 #undef MAGIC_ENUM_GET_ENUM_NAME_BUILTIN
 #undef MAGIC_ENUM_GET_TYPE_NAME_BUILTIN
+#undef MAGIC_ENUM_CALLING_CONVENTION
 #undef MAGIC_ENUM_VS_2017_WORKAROUND
 #undef MAGIC_ENUM_ARRAY_CONSTEXPR
 #undef MAGIC_ENUM_FOR_EACH_256

include/magic_enum/magic_enum_utility.hpp

@@ -42,6 +42,9 @@ namespace magic_enum {
 
 namespace detail {
 
+template <typename E, enum_subtype S, typename F, std::size_t J>
+using enum_for_each_result_t = std::decay_t<std::invoke_result_t<F&, enum_constant<values_v<E, S>[J]>>>;
+
 template <typename E, enum_subtype S, typename F, std::size_t... J>
 constexpr auto for_each(F&& f, std::index_sequence<J...>) {
   constexpr bool has_void_return = (std::is_void_v<std::invoke_result_t<F&, enum_constant<values_v<E, S>[J]>>> || ...);
@@ -50,9 +53,9 @@ constexpr auto for_each(F&& f, std::index_sequence<J...>) {
   if constexpr (has_void_return) {
     (f(enum_constant<values_v<E, S>[J]>{}), ...);
   } else if constexpr (all_same_return) {
-    return std::array{f(enum_constant<values_v<E, S>[J]>{})...};
+    return std::array<enum_for_each_result_t<E, S, F, 0>, sizeof...(J)>{{f(enum_constant<values_v<E, S>[J]>{})...}};
   } else {
-    return std::tuple{f(enum_constant<values_v<E, S>[J]>{})...};
+    return std::tuple<enum_for_each_result_t<E, S, F, J>...>{f(enum_constant<values_v<E, S>[J]>{})...};
   }
 }
 

test/CMakeLists.txt

@@ -144,6 +144,27 @@ endfunction()
 magic_enum_add_tests(cpp17 c++17)
 magic_enum_make_test(test_range.cpp test_range-cpp17 c++17)
 
+if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+  target_compile_definitions(test-cpp17 PRIVATE MAGIC_ENUM_TEST_VS_2017_WORKAROUND=1)
+  if(MSVC_VERSION GREATER_EQUAL 1920)
+    # Exercise the Visual Studio 2017 fallback on current MSVC too.
+    target_compile_definitions(test-cpp17 PRIVATE MAGIC_ENUM_VS_2017_WORKAROUND=1)
+  endif()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+  set(MAGIC_ENUM_TEST_CLR_OBJECT "${CMAKE_CURRENT_BINARY_DIR}/test_clr.obj")
+  add_custom_command(
+    OUTPUT "${MAGIC_ENUM_TEST_CLR_OBJECT}"
+    COMMAND "${CMAKE_CXX_COMPILER}" /nologo /std:c++17 /clr /EHa /W4 /WX /permissive-
+            "/I${PROJECT_SOURCE_DIR}/include" /c "${PROJECT_SOURCE_DIR}/example/example.cpp"
+            "/Fo${MAGIC_ENUM_TEST_CLR_OBJECT}"
+    DEPENDS "${PROJECT_SOURCE_DIR}/example/example.cpp" "${PROJECT_SOURCE_DIR}/include/magic_enum/magic_enum.hpp"
+    VERBATIM
+  )
+  add_custom_target(test_clr DEPENDS "${MAGIC_ENUM_TEST_CLR_OBJECT}")
+endif()
+
 foreach(MAGIC_ENUM_TEST_STANDARD IN LISTS MAGIC_ENUM_TEST_STANDARDS)
   set(MAGIC_ENUM_HAS_STANDARD_FLAG MAGIC_ENUM_HAS_CPP${MAGIC_ENUM_TEST_STANDARD}_FLAG)
   if(NOT ${MAGIC_ENUM_HAS_STANDARD_FLAG})

test/test.cpp

@@ -15,6 +15,10 @@
 #include <magic_enum/magic_enum_switch.hpp>
 #include <magic_enum/magic_enum_utility.hpp>
 
+#if defined(MAGIC_ENUM_CALLING_CONVENTION) || defined(MAGIC_ENUM_VS_2017_WORKAROUND) || defined(MAGIC_ENUM_ARRAY_CONSTEXPR)
+#  error Internal macro leaked from magic_enum.hpp.
+#endif
+
 #include "test_helpers.hpp"
 
 #include <array>
@@ -35,6 +39,14 @@ constexpr magic_enum::customize::customize_t magic_enum::customize::enum_name<Co
 
 enum class Numbers : int { one = 1, two, three, many = 127 };
 
+#if defined(MAGIC_ENUM_TEST_VS_2017_WORKAROUND)
+template <typename, typename>
+struct templated_scope {
+  enum class Value { ONE, TWO };
+};
+using TemplatedValue = templated_scope<int, long>::Value;
+#endif
+
 enum Directions { Up = 85, Down = -42, Right = 120, Left = -120 };
 
 enum number : unsigned long {
@@ -522,6 +534,10 @@ TEST_CASE("enum_count") {
 
   constexpr auto s6 = enum_count<MaxUsedAsInvalid>();
   REQUIRE(s6 == 2);
+
+#if defined(MAGIC_ENUM_TEST_VS_2017_WORKAROUND)
+  REQUIRE(enum_count<TemplatedValue>() == 2);
+#endif
 }
 
 enum lt1 { s1, loooooooooooooooooooong1 };
@@ -628,6 +644,9 @@ TEST_CASE("enum_name") {
     REQUIRE(enum_name(static_cast<number>(0)).empty());
 
     REQUIRE(enum_name(MaxUsedAsInvalid::ONE) == "ONE");
+#if defined(MAGIC_ENUM_TEST_VS_2017_WORKAROUND)
+    REQUIRE(enum_name(TemplatedValue::ONE) == "ONE");
+#endif
 
     REQUIRE(enum_name(lt1::s1) == "s1");
     REQUIRE(enum_name(lt1::loooooooooooooooooooong1) == "loooooooooooooooooooong1");
@@ -1113,7 +1132,7 @@ TEST_CASE("extrema") {
     REQUIRE(magic_enum::detail::reflected_min<Directions, as_common<>>() == MAGIC_ENUM_RANGE_MIN);
     REQUIRE(magic_enum::detail::min_v<Directions, as_common<>> == -120);
 
-    REQUIRE(magic_enum::customize::enum_range<number>::min == 100);
+    REQUIRE(static_cast<int>(magic_enum::customize::enum_range<number>::min) == 100);
     REQUIRE(magic_enum::detail::reflected_min<number, as_common<>>() == 100);
     REQUIRE(magic_enum::detail::min_v<number, as_common<>> == 100);
 
@@ -1141,7 +1160,7 @@ TEST_CASE("extrema") {
     REQUIRE(magic_enum::detail::reflected_max<Directions, as_common<>>() == MAGIC_ENUM_RANGE_MAX);
     REQUIRE(magic_enum::detail::max_v<Directions, as_common<>> == 120);
 
-    REQUIRE(magic_enum::customize::enum_range<number>::max == 300);
+    REQUIRE(static_cast<int>(magic_enum::customize::enum_range<number>::max) == 300);
     REQUIRE(magic_enum::detail::reflected_max<number, as_common<>>() == 300);
     REQUIRE(magic_enum::detail::max_v<number, as_common<>> == 300);
 
@@ -1275,13 +1294,13 @@ TEST_CASE("enum_for_each") {
     constexpr auto workResults = enum_for_each<Color>([](auto val) {
       return DoWork<val>();
     });
-    REQUIRE(workResults == std::array<std::string_view, 3>{"default", "override", "default"});
+    REQUIRE(workResults == std::array<std::string_view, 3>{{"default", "override", "default"}});
 
     constexpr auto colorSequence = std::make_index_sequence<enum_count<Color>()>{};
     static_assert(detail::all_invocable<Color, detail::subtype_v<Color>, LvalueOnlyForEach>(colorSequence));
     static_assert(!detail::all_invocable<Color, detail::subtype_v<Color>, RvalueOnlyForEach>(colorSequence));
     constexpr auto colorValues = enum_for_each<Color>(LvalueOnlyForEach{});
-    REQUIRE(colorValues == std::array<int, 3>{-12, 7, 15});
+    REQUIRE(colorValues == std::array<int, 3>{{-12, 7, 15}});
   }
 
   SUBCASE("different return type") {