Use intrinsics for unreachable to support C++20

patrickroberts · patrickroberts · commit 75a090b88874 · 2025-02-07T23:56:09.000-06:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -70,8 +70,7 @@ include(GNUInstallDirs)
 add_library(beman.any_view INTERFACE)
 add_library(beman::any_view ALIAS beman.any_view)
 set_target_properties(beman.any_view PROPERTIES CXX_EXTENSIONS OFF)
-# TODO: discuss removal of std::unreachable() to revert to C++20
-target_compile_features(beman.any_view INTERFACE cxx_std_23)
+target_compile_features(beman.any_view INTERFACE cxx_std_20)
 target_include_directories(
     beman.any_view
     INTERFACE
diff --git a/include/beman/any_view/detail/iterator_adaptor.hpp b/include/beman/any_view/detail/iterator_adaptor.hpp
@@ -4,10 +4,10 @@
 #define BEMAN_ANY_VIEW_DETAIL_ITERATOR_ADAPTOR_HPP
 
 #include <beman/any_view/detail/iterator_interface.hpp>
+#include <beman/any_view/detail/utility.hpp>
 
 #include <compare>
 #include <iterator>
-#include <utility>
 
 namespace beman::any_view::detail {
 
@@ -34,6 +34,10 @@ class iterator_adaptor : public iterator_interface<IterConceptT, ElementT, RefT,
     static constexpr bool random_access = std::derived_from<IterConceptT, std::random_access_iterator_tag>;
     static constexpr bool contiguous    = std::derived_from<IterConceptT, std::contiguous_iterator_tag>;
 
+    static constexpr auto down_cast(const iterator_interface& other) {
+        return dynamic_cast<const iterator_adaptor*>(std::addressof(other));
+    }
+
   public:
     constexpr iterator_adaptor(IteratorT&& iterator, SentinelT&& sentinel) noexcept(get_noexcept())
         : iterator(std::move(iterator)), sentinel(std::move(sentinel)) {}
@@ -42,7 +46,7 @@ class iterator_adaptor : public iterator_interface<IterConceptT, ElementT, RefT,
         if constexpr (std::copy_constructible<IteratorT> and std::copy_constructible<SentinelT>) {
             ::new (destination) iterator_adaptor(*this);
         } else {
-            std::unreachable();
+            unreachable();
         }
     }
 
@@ -51,15 +55,15 @@ class iterator_adaptor : public iterator_interface<IterConceptT, ElementT, RefT,
                       std::is_nothrow_move_constructible_v<SentinelT>) {
             ::new (destination) iterator_adaptor(std::move(*this));
         } else {
-            std::unreachable();
+            unreachable();
         }
     }
 
     [[nodiscard]] constexpr auto copy() const -> iterator_adaptor* override {
         if constexpr (std::copy_constructible<IteratorT> and std::copy_constructible<SentinelT>) {
             return new iterator_adaptor(*this);
         } else {
-            std::unreachable();
+            unreachable();
         }
     }
 
@@ -71,16 +75,16 @@ class iterator_adaptor : public iterator_interface<IterConceptT, ElementT, RefT,
         if constexpr (contiguous) {
             return std::to_address(iterator);
         } else {
-            std::unreachable();
+            unreachable();
         }
     }
 
     constexpr auto operator++() -> void override { ++iterator; }
 
     [[nodiscard]] constexpr auto operator==(const iterator_interface& other) const -> bool override {
         if constexpr (forward) {
-            if (type() == other.type()) {
-                return iterator == static_cast<const iterator_adaptor&>(other).iterator;
+            if (const auto adaptor = down_cast(other)) {
+                return iterator == adaptor->iterator;
             }
         }
 
@@ -91,14 +95,14 @@ class iterator_adaptor : public iterator_interface<IterConceptT, ElementT, RefT,
         if constexpr (bidirectional) {
             --iterator;
         } else {
-            std::unreachable();
+            unreachable();
         }
     }
 
     [[nodiscard]] constexpr auto operator<=>(const iterator_interface& other) const -> std::partial_ordering override {
         if constexpr (random_access) {
-            if (type() == other.type()) {
-                return iterator <=> static_cast<const iterator_adaptor&>(other).iterator;
+            if (const auto adaptor = down_cast(other)) {
+                return iterator <=> adaptor->iterator;
             }
         }
 
@@ -107,29 +111,25 @@ class iterator_adaptor : public iterator_interface<IterConceptT, ElementT, RefT,
 
     [[nodiscard]] constexpr auto operator-(const iterator_interface& other) const -> DiffT override {
         if constexpr (random_access) {
-            if (type() == other.type()) {
-                return iterator - static_cast<const iterator_adaptor&>(other).iterator;
+            if (const auto adaptor = down_cast(other)) {
+                return iterator - adaptor->iterator;
             }
         }
 
-        std::unreachable();
+        unreachable();
     }
 
     constexpr auto operator+=(DiffT offset) -> void override {
         if constexpr (random_access) {
             iterator += offset;
         } else {
-            std::unreachable();
+            unreachable();
         }
     }
 
     [[nodiscard]] constexpr auto operator==(std::default_sentinel_t) const -> bool override {
         return iterator == sentinel;
     }
-
-    [[nodiscard]] constexpr auto type() const noexcept -> const std::type_info& override {
-        return typeid(iterator_adaptor);
-    }
 };
 
 } // namespace beman::any_view::detail
diff --git a/include/beman/any_view/detail/iterator_interface.hpp b/include/beman/any_view/detail/iterator_interface.hpp
@@ -6,7 +6,6 @@
 #include <compare>
 #include <iterator>
 #include <type_traits>
-#include <typeinfo>
 
 namespace beman::any_view::detail {
 
@@ -44,9 +43,6 @@ class iterator_interface {
 
     [[nodiscard]] virtual constexpr auto operator==(std::default_sentinel_t sentinel) const -> bool = 0;
 
-    // type query
-    [[nodiscard]] virtual constexpr auto type() const noexcept -> const std::type_info& = 0;
-
     virtual constexpr ~iterator_interface() noexcept = default;
 };
 
diff --git a/include/beman/any_view/detail/utility.hpp b/include/beman/any_view/detail/utility.hpp
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef BEMAN_ANY_VIEW_DETAIL_UTILITY_HPP
+#define BEMAN_ANY_VIEW_DETAIL_UTILITY_HPP
+
+namespace beman::any_view::detail {
+
+[[noreturn]] inline auto unreachable() -> void {
+#if defined(_MSC_VER)
+    __assume(false);
+#elif defined(__GNUG__)
+    __builtin_unreachable();
+#endif
+}
+
+} // namespace beman::any_view::detail
+
+#endif // BEMAN_ANY_VIEW_DETAIL_UTILITY_HPP
diff --git a/include/beman/any_view/detail/view_adaptor.hpp b/include/beman/any_view/detail/view_adaptor.hpp
@@ -4,10 +4,10 @@
 #define BEMAN_ANY_VIEW_DETAIL_VIEW_ADAPTOR_HPP
 
 #include <beman/any_view/detail/concepts.hpp>
+#include <beman/any_view/detail/utility.hpp>
 #include <beman/any_view/detail/view_interface.hpp>
 
 #include <ranges>
-#include <utility>
 
 namespace beman::any_view::detail {
 
@@ -27,31 +27,31 @@ class view_adaptor : public view_interface<IterConceptT, ElementT, RefT, RValueR
         if constexpr (std::copy_constructible<ViewT>) {
             ::new (destination) view_adaptor(*this);
         } else {
-            std::unreachable();
+            unreachable();
         }
     }
 
     auto move_to(void* destination) noexcept -> void override {
         if constexpr (std::is_nothrow_move_constructible_v<ViewT>) {
             ::new (destination) view_adaptor(std::move(*this));
         } else {
-            std::unreachable();
+            unreachable();
         }
     }
 
     [[nodiscard]] constexpr auto copy() const -> view_adaptor* override {
         if constexpr (std::copy_constructible<ViewT>) {
             return new view_adaptor(*this);
         } else {
-            std::unreachable();
+            unreachable();
         }
     }
 
     [[nodiscard]] constexpr auto begin() -> iterator override {
         if constexpr (contiguous_reference_convertible_to<std::ranges::range_reference_t<ViewT>, RefT, IterConceptT>) {
             return iterator{std::ranges::begin(view), std::ranges::end(view)};
         } else {
-            std::unreachable();
+            unreachable();
         }
     }
 
@@ -64,14 +64,14 @@ class view_adaptor : public view_interface<IterConceptT, ElementT, RefT, RValueR
             }
         }
 
-        std::unreachable();
+        unreachable();
     }
 
     [[nodiscard]] constexpr auto size() const -> size_type override {
         if constexpr (std::ranges::sized_range<ViewT>) {
             return std::ranges::size(view);
         } else {
-            std::unreachable();
+            unreachable();
         }
     }
 };

Original file line number	Diff line number	Diff line change
`@@ -4,10 +4,10 @@`
`4`	`4`	`#define BEMAN_ANY_VIEW_DETAIL_ITERATOR_ADAPTOR_HPP`
`5`	`5`
`6`	`6`	`#include <beman/any_view/detail/iterator_interface.hpp>`
	`7`	`+#include <beman/any_view/detail/utility.hpp>`
`7`	`8`
`8`	`9`	`#include <compare>`
`9`	`10`	`#include <iterator>`
`10`		`-#include <utility>`
`11`	`11`
`12`	`12`	`namespace beman::any_view::detail {`
`13`	`13`
`@@ -34,6 +34,10 @@ class iterator_adaptor : public iterator_interface<IterConceptT, ElementT, RefT,`
`34`	`34`	`static constexpr bool random_access = std::derived_from<IterConceptT, std::random_access_iterator_tag>;`
`35`	`35`	`static constexpr bool contiguous = std::derived_from<IterConceptT, std::contiguous_iterator_tag>;`
`36`	`36`
	`37`	`+ static constexpr auto down_cast(const iterator_interface& other) {`
	`38`	`+ return dynamic_cast<const iterator_adaptor*>(std::addressof(other));`
	`39`	`+ }`
	`40`	`+`
`37`	`41`	`public:`
`38`	`42`	`constexpr iterator_adaptor(IteratorT&& iterator, SentinelT&& sentinel) noexcept(get_noexcept())`
`39`	`43`	`: iterator(std::move(iterator)), sentinel(std::move(sentinel)) {}`
`@@ -42,7 +46,7 @@ class iterator_adaptor : public iterator_interface<IterConceptT, ElementT, RefT,`
`42`	`46`	`if constexpr (std::copy_constructible<IteratorT> and std::copy_constructible<SentinelT>) {`
`43`	`47`	`::new (destination) iterator_adaptor(*this);`
`44`	`48`	`} else {`
`45`		`- std::unreachable();`
	`49`	`+ unreachable();`
`46`	`50`	`}`
`47`	`51`	`}`
`48`	`52`
`@@ -51,15 +55,15 @@ class iterator_adaptor : public iterator_interface<IterConceptT, ElementT, RefT,`
`51`	`55`	`std::is_nothrow_move_constructible_v<SentinelT>) {`
`52`	`56`	`::new (destination) iterator_adaptor(std::move(*this));`
`53`	`57`	`} else {`
`54`		`- std::unreachable();`
	`58`	`+ unreachable();`
`55`	`59`	`}`
`56`	`60`	`}`
`57`	`61`
`58`	`62`	`[[nodiscard]] constexpr auto copy() const -> iterator_adaptor* override {`
`59`	`63`	`if constexpr (std::copy_constructible<IteratorT> and std::copy_constructible<SentinelT>) {`
`60`	`64`	`return new iterator_adaptor(*this);`
`61`	`65`	`} else {`
`62`		`- std::unreachable();`
	`66`	`+ unreachable();`
`63`	`67`	`}`
`64`	`68`	`}`
`65`	`69`
`@@ -71,16 +75,16 @@ class iterator_adaptor : public iterator_interface<IterConceptT, ElementT, RefT,`
`71`	`75`	`if constexpr (contiguous) {`
`72`	`76`	`return std::to_address(iterator);`
`73`	`77`	`} else {`
`74`		`- std::unreachable();`
	`78`	`+ unreachable();`
`75`	`79`	`}`
`76`	`80`	`}`
`77`	`81`
`78`	`82`	`constexpr auto operator++() -> void override { ++iterator; }`
`79`	`83`
`80`	`84`	`[[nodiscard]] constexpr auto operator==(const iterator_interface& other) const -> bool override {`
`81`	`85`	`if constexpr (forward) {`
`82`		`- if (type() == other.type()) {`
`83`		`- return iterator == static_cast<const iterator_adaptor&>(other).iterator;`
	`86`	`+ if (const auto adaptor = down_cast(other)) {`
	`87`	`+ return iterator == adaptor->iterator;`
`84`	`88`	`}`
`85`	`89`	`}`
`86`	`90`
`@@ -91,14 +95,14 @@ class iterator_adaptor : public iterator_interface<IterConceptT, ElementT, RefT,`
`91`	`95`	`if constexpr (bidirectional) {`
`92`	`96`	`--iterator;`
`93`	`97`	`} else {`
`94`		`- std::unreachable();`
	`98`	`+ unreachable();`
`95`	`99`	`}`
`96`	`100`	`}`
`97`	`101`
`98`	`102`	`[[nodiscard]] constexpr auto operator<=>(const iterator_interface& other) const -> std::partial_ordering override {`
`99`	`103`	`if constexpr (random_access) {`
`100`		`- if (type() == other.type()) {`
`101`		`- return iterator <=> static_cast<const iterator_adaptor&>(other).iterator;`
	`104`	`+ if (const auto adaptor = down_cast(other)) {`
	`105`	`+ return iterator <=> adaptor->iterator;`
`102`	`106`	`}`
`103`	`107`	`}`
`104`	`108`
`@@ -107,29 +111,25 @@ class iterator_adaptor : public iterator_interface<IterConceptT, ElementT, RefT,`
`107`	`111`
`108`	`112`	`[[nodiscard]] constexpr auto operator-(const iterator_interface& other) const -> DiffT override {`
`109`	`113`	`if constexpr (random_access) {`
`110`		`- if (type() == other.type()) {`
`111`		`- return iterator - static_cast<const iterator_adaptor&>(other).iterator;`
	`114`	`+ if (const auto adaptor = down_cast(other)) {`
	`115`	`+ return iterator - adaptor->iterator;`
`112`	`116`	`}`
`113`	`117`	`}`
`114`	`118`
`115`		`- std::unreachable();`
	`119`	`+ unreachable();`
`116`	`120`	`}`
`117`	`121`
`118`	`122`	`constexpr auto operator+=(DiffT offset) -> void override {`
`119`	`123`	`if constexpr (random_access) {`
`120`	`124`	`iterator += offset;`
`121`	`125`	`} else {`
`122`		`- std::unreachable();`
	`126`	`+ unreachable();`
`123`	`127`	`}`
`124`	`128`	`}`
`125`	`129`
`126`	`130`	`[[nodiscard]] constexpr auto operator==(std::default_sentinel_t) const -> bool override {`
`127`	`131`	`return iterator == sentinel;`
`128`	`132`	`}`
`129`		`-`
`130`		`- [[nodiscard]] constexpr auto type() const noexcept -> const std::type_info& override {`
`131`		`- return typeid(iterator_adaptor);`
`132`		`- }`
`133`	`133`	`};`
`134`	`134`
`135`	`135`	`} // namespace beman::any_view::detail`
Original file line number	Diff line number	Diff line change
`@@ -4,10 +4,10 @@`
`4`	`4`	`#define BEMAN_ANY_VIEW_DETAIL_VIEW_ADAPTOR_HPP`
`5`	`5`
`6`	`6`	`#include <beman/any_view/detail/concepts.hpp>`
	`7`	`+#include <beman/any_view/detail/utility.hpp>`
`7`	`8`	`#include <beman/any_view/detail/view_interface.hpp>`
`8`	`9`
`9`	`10`	`#include <ranges>`
`10`		`-#include <utility>`
`11`	`11`
`12`	`12`	`namespace beman::any_view::detail {`
`13`	`13`
`@@ -27,31 +27,31 @@ class view_adaptor : public view_interface<IterConceptT, ElementT, RefT, RValueR`
`27`	`27`	`if constexpr (std::copy_constructible<ViewT>) {`
`28`	`28`	`::new (destination) view_adaptor(*this);`
`29`	`29`	`} else {`
`30`		`- std::unreachable();`
	`30`	`+ unreachable();`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`auto move_to(void* destination) noexcept -> void override {`
`35`	`35`	`if constexpr (std::is_nothrow_move_constructible_v<ViewT>) {`
`36`	`36`	`::new (destination) view_adaptor(std::move(*this));`
`37`	`37`	`} else {`
`38`		`- std::unreachable();`
	`38`	`+ unreachable();`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`[[nodiscard]] constexpr auto copy() const -> view_adaptor* override {`
`43`	`43`	`if constexpr (std::copy_constructible<ViewT>) {`
`44`	`44`	`return new view_adaptor(*this);`
`45`	`45`	`} else {`
`46`		`- std::unreachable();`
	`46`	`+ unreachable();`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`[[nodiscard]] constexpr auto begin() -> iterator override {`
`51`	`51`	`if constexpr (contiguous_reference_convertible_to<std::ranges::range_reference_t<ViewT>, RefT, IterConceptT>) {`
`52`	`52`	`return iterator{std::ranges::begin(view), std::ranges::end(view)};`
`53`	`53`	`} else {`
`54`		`- std::unreachable();`
	`54`	`+ unreachable();`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`@@ -64,14 +64,14 @@ class view_adaptor : public view_interface<IterConceptT, ElementT, RefT, RValueR`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`
`67`		`- std::unreachable();`
	`67`	`+ unreachable();`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`[[nodiscard]] constexpr auto size() const -> size_type override {`
`71`	`71`	`if constexpr (std::ranges::sized_range<ViewT>) {`
`72`	`72`	`return std::ranges::size(view);`
`73`	`73`	`} else {`
`74`		`- std::unreachable();`
	`74`	`+ unreachable();`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`	`};`