is(): correct is() for types (hsutter#1204)

filipsajdak · web-flow · commit df73616ed55d · 2024-08-10T12:07:09.000-07:00
* Remove invalid check

Non-polymorphic types cannot be casted with dynamic_cast

* Remove dead code

std::is_polymorphic_v&lt;X&gt; when X is pointer returns false
that means that later std::is_pointer_v&lt;X&gt; will always be false

* Remove extra parens

* Fix formating

* Add test for is with polymorphic types

* is(): add support for pointers

Support for is&lt;X*&gt;(ptr)

* Update of tests to support is() with pointers

* is(): add support for nullptr_t

* is(): add test for nullptr_t

* Add tests against unrelated type

* is(): made is() compile-time when possible

* is(): fix test when is() returns std::bool_constant

* Fix polymorphic tests

* Remove empty .cpp.output files
diff --git a/include/cpp2util.h b/include/cpp2util.h
@@ -1635,39 +1635,44 @@ constexpr auto is( X&& ) {
 //  Types
 //
 template< typename C, typename X >
-auto is( X const& x ) -> bool {
+constexpr auto is( X const& x ) -> auto {
     if constexpr (
         std::is_same_v<C, X>
         || std::is_base_of_v<C, X>
     )
     {
-        return true;
+        return std::true_type{};
     }
     else if constexpr (
-        std::is_base_of_v<X, C>
-        || (
-            std::is_polymorphic_v<C>
-            && std::is_polymorphic_v<X>
-            )
+        std::is_polymorphic_v<C>
+        && std::is_polymorphic_v<X>
     )
     {
-        if constexpr (std::is_pointer_v<X>) {
-            return Dynamic_cast<C const*>(x) != nullptr;
-        }
-        else {
-            return Dynamic_cast<C const*>(&x) != nullptr;
-        }
+        return Dynamic_cast<C const*>(&x) != nullptr;
     }
     else if constexpr (
-        requires { *x; X(); }
+        (
+            std::is_same_v<X, std::nullptr_t>
+            || requires { *x; X(); }
+        )
         && std::is_same_v<C, empty>
     )
     {
         return x == X();
     }
-    else {
+    else if constexpr (
+        std::is_pointer_v<C>
+        && std::is_pointer_v<X>
+    )
+    {
+        if (x != nullptr) {
+            return bool{is<std::remove_pointer_t<C>>(*x)};
+        }
         return false;
     }
+    else {
+        return std::false_type{};
+    }
 }
 
 
diff --git a/regression-tests/mixed-type-safety-1.cpp2 b/regression-tests/mixed-type-safety-1.cpp2
@@ -10,7 +10,8 @@ class Square : public Shape { };
 
 //--- printing helpers -----------------
 
-print: ( msg: std::string, x: _ ) =
+print: <T : type> ( msg: std::string, x: T ) 
+       requires !std::convertible_to<T, bool> =
     std::cout << msg << x << "\n";
 
 print: ( msg: std::string, b: bool ) =
diff --git a/regression-tests/pure2-is-with-polymorphic-types.cpp2 b/regression-tests/pure2-is-with-polymorphic-types.cpp2
@@ -0,0 +1,45 @@
+A: type = {}
+
+VA: @polymorphic_base <I:int> type = {}
+
+VC: type = {
+    this: VA<0>;
+    this: VA<1>;
+}
+
+VD: type = {
+    this: VA<0>;
+}
+
+fun: (v, name) = {
+    std::cout << "(name)$ is";
+    if v is VC    { std::cout <<  " VC"; }
+    if v is VA<0> { std::cout <<  " VA<0>"; }
+    if v is VA<1> { std::cout <<  " VA<1>"; }
+    if v is VD    { std::cout <<  " VD"; }
+    if v is *VC    { std::cout <<  " *VC"; }
+    if v is *VA<0> { std::cout <<  " *VA<0>"; }
+    if v is *VA<1> { std::cout <<  " *VA<1>"; }
+    if v is *VD    { std::cout <<  " *VD"; }
+    if v is void  { std::cout <<  " empty"; }
+    if v is A  { std::cout <<  " A"; }
+    std::cout << std::endl;
+}
+
+main: () = {
+
+    vc : VC = ();
+    p0 : *VA<0> = vc&;
+    p1 : *VA<1> = vc&;
+
+    fun(vc, "vc");
+    fun(p0*, "p0*");
+    fun(p1*, "p1*");
+
+    fun(vc&, "vc&");
+    fun(p0, "p0");
+    fun(p1, "p1");
+
+    fun(nullptr, "nullptr");
+    fun(A(), "A");
+}
diff --git a/regression-tests/test-results/apple-clang-14-c++2b/pure2-is-with-polymorphic-types.cpp.execution b/regression-tests/test-results/apple-clang-14-c++2b/pure2-is-with-polymorphic-types.cpp.execution
@@ -0,0 +1,8 @@
+vc is VC VA<0> VA<1>
+p0* is VC VA<0> VA<1>
+p1* is VC VA<0> VA<1>
+vc& is *VC *VA<0> *VA<1>
+p0 is *VC *VA<0> *VA<1>
+p1 is *VC *VA<0> *VA<1>
+nullptr is empty
+A is A
diff --git a/regression-tests/test-results/apple-clang-15-c++2b/pure2-is-with-polymorphic-types.cpp.execution b/regression-tests/test-results/apple-clang-15-c++2b/pure2-is-with-polymorphic-types.cpp.execution
@@ -0,0 +1,8 @@
+vc is VC VA<0> VA<1>
+p0* is VC VA<0> VA<1>
+p1* is VC VA<0> VA<1>
+vc& is *VC *VA<0> *VA<1>
+p0 is *VC *VA<0> *VA<1>
+p1 is *VC *VA<0> *VA<1>
+nullptr is empty
+A is A
diff --git a/regression-tests/test-results/clang-12-c++20/pure2-is-with-polymorphic-types.cpp.execution b/regression-tests/test-results/clang-12-c++20/pure2-is-with-polymorphic-types.cpp.execution
@@ -0,0 +1,8 @@
+vc is VC VA<0> VA<1>
+p0* is VC VA<0> VA<1>
+p1* is VC VA<0> VA<1>
+vc& is *VC *VA<0> *VA<1>
+p0 is *VC *VA<0> *VA<1>
+p1 is *VC *VA<0> *VA<1>
+nullptr is empty
+A is A
diff --git a/regression-tests/test-results/clang-15-c++20-libcpp/pure2-is-with-polymorphic-types.cpp.execution b/regression-tests/test-results/clang-15-c++20-libcpp/pure2-is-with-polymorphic-types.cpp.execution
@@ -0,0 +1,8 @@
+vc is VC VA<0> VA<1>
+p0* is VC VA<0> VA<1>
+p1* is VC VA<0> VA<1>
+vc& is *VC *VA<0> *VA<1>
+p0 is *VC *VA<0> *VA<1>
+p1 is *VC *VA<0> *VA<1>
+nullptr is empty
+A is A
diff --git a/regression-tests/test-results/clang-15-c++20/pure2-is-with-polymorphic-types.cpp.execution b/regression-tests/test-results/clang-15-c++20/pure2-is-with-polymorphic-types.cpp.execution
@@ -0,0 +1,8 @@
+vc is VC VA<0> VA<1>
+p0* is VC VA<0> VA<1>
+p1* is VC VA<0> VA<1>
+vc& is *VC *VA<0> *VA<1>
+p0 is *VC *VA<0> *VA<1>
+p1 is *VC *VA<0> *VA<1>
+nullptr is empty
+A is A
diff --git a/regression-tests/test-results/clang-18-c++20/pure2-is-with-polymorphic-types.cpp.execution b/regression-tests/test-results/clang-18-c++20/pure2-is-with-polymorphic-types.cpp.execution
@@ -0,0 +1,8 @@
+vc is VC VA<0> VA<1>
+p0* is VC VA<0> VA<1>
+p1* is VC VA<0> VA<1>
+vc& is *VC *VA<0> *VA<1>
+p0 is *VC *VA<0> *VA<1>
+p1 is *VC *VA<0> *VA<1>
+nullptr is empty
+A is A
diff --git a/regression-tests/test-results/clang-18-c++23-libcpp/pure2-is-with-polymorphic-types.cpp.execution b/regression-tests/test-results/clang-18-c++23-libcpp/pure2-is-with-polymorphic-types.cpp.execution
@@ -0,0 +1,8 @@
+vc is VC VA<0> VA<1>
+p0* is VC VA<0> VA<1>
+p1* is VC VA<0> VA<1>
+vc& is *VC *VA<0> *VA<1>
+p0 is *VC *VA<0> *VA<1>
+p1 is *VC *VA<0> *VA<1>
+nullptr is empty
+A is A
diff --git a/regression-tests/test-results/gcc-10-c++20/pure2-is-with-polymorphic-types.cpp.execution b/regression-tests/test-results/gcc-10-c++20/pure2-is-with-polymorphic-types.cpp.execution
@@ -0,0 +1,8 @@
+vc is VC VA<0> VA<1>
+p0* is VC VA<0> VA<1>
+p1* is VC VA<0> VA<1>
+vc& is *VC *VA<0> *VA<1>
+p0 is *VC *VA<0> *VA<1>
+p1 is *VC *VA<0> *VA<1>
+nullptr is empty
+A is A
diff --git a/regression-tests/test-results/gcc-13-c++2b/pure2-is-with-polymorphic-types.cpp.execution b/regression-tests/test-results/gcc-13-c++2b/pure2-is-with-polymorphic-types.cpp.execution
@@ -0,0 +1,8 @@
+vc is VC VA<0> VA<1>
+p0* is VC VA<0> VA<1>
+p1* is VC VA<0> VA<1>
+vc& is *VC *VA<0> *VA<1>
+p0 is *VC *VA<0> *VA<1>
+p1 is *VC *VA<0> *VA<1>
+nullptr is empty
+A is A
diff --git a/regression-tests/test-results/gcc-14-c++2b/pure2-is-with-polymorphic-types.cpp.execution b/regression-tests/test-results/gcc-14-c++2b/pure2-is-with-polymorphic-types.cpp.execution
@@ -0,0 +1,8 @@
+vc is VC VA<0> VA<1>
+p0* is VC VA<0> VA<1>
+p1* is VC VA<0> VA<1>
+vc& is *VC *VA<0> *VA<1>
+p0 is *VC *VA<0> *VA<1>
+p1 is *VC *VA<0> *VA<1>
+nullptr is empty
+A is A
diff --git a/regression-tests/test-results/mixed-type-safety-1.cpp b/regression-tests/test-results/mixed-type-safety-1.cpp
@@ -24,12 +24,13 @@ class Square : public Shape { };
 //--- printing helpers -----------------
 
 #line 13 "mixed-type-safety-1.cpp2"
-auto print(cpp2::impl::in<std::string> msg, auto const& x) -> void;
+template<typename T> auto print(cpp2::impl::in<std::string> msg, T const& x) -> void
+CPP2_REQUIRES (!(std::convertible_to<T,bool>)) ;
 
-#line 16 "mixed-type-safety-1.cpp2"
+#line 17 "mixed-type-safety-1.cpp2"
 auto print(cpp2::impl::in<std::string> msg, cpp2::impl::in<bool> b) -> void;
 
-#line 24 "mixed-type-safety-1.cpp2"
+#line 25 "mixed-type-safety-1.cpp2"
 //--- examples -------------------------
 
 [[nodiscard]] auto main() -> int;
@@ -39,10 +40,13 @@ auto print(cpp2::impl::in<std::string> msg, cpp2::impl::in<bool> b) -> void;
 #line 1 "mixed-type-safety-1.cpp2"
 
 #line 13 "mixed-type-safety-1.cpp2"
-auto print(cpp2::impl::in<std::string> msg, auto const& x) -> void { 
+template<typename T> auto print(cpp2::impl::in<std::string> msg, T const& x) -> void
+requires (!(std::convertible_to<T,bool>))  { 
+
+#line 15 "mixed-type-safety-1.cpp2"
     std::cout << msg << x << "\n";  }
 
-#line 16 "mixed-type-safety-1.cpp2"
+#line 17 "mixed-type-safety-1.cpp2"
 auto print(cpp2::impl::in<std::string> msg, cpp2::impl::in<bool> b) -> void
 {
     cpp2::impl::deferred_init<char const*> bmsg; 
@@ -51,7 +55,7 @@ auto print(cpp2::impl::in<std::string> msg, cpp2::impl::in<bool> b) -> void
     std::cout << msg << cpp2::move(bmsg.value()) << "\n";
 }
 
-#line 26 "mixed-type-safety-1.cpp2"
+#line 27 "mixed-type-safety-1.cpp2"
 [[nodiscard]] auto main() -> int
 {
     print("1.1 is int? ", cpp2::impl::is<int>(1.1));
diff --git a/regression-tests/test-results/msvc-2022-c++20/pure2-is-with-polymorphic-types.cpp.execution b/regression-tests/test-results/msvc-2022-c++20/pure2-is-with-polymorphic-types.cpp.execution
@@ -0,0 +1,8 @@
+vc is VC VA<0> VA<1>
+p0* is VC VA<0> VA<1>
+p1* is VC VA<0> VA<1>
+vc& is *VC *VA<0> *VA<1>
+p0 is *VC *VA<0> *VA<1>
+p1 is *VC *VA<0> *VA<1>
+nullptr is empty
+A is A
diff --git a/regression-tests/test-results/msvc-2022-c++latest/pure2-is-with-polymorphic-types.cpp.execution b/regression-tests/test-results/msvc-2022-c++latest/pure2-is-with-polymorphic-types.cpp.execution
@@ -0,0 +1,8 @@
+vc is VC VA<0> VA<1>
+p0* is VC VA<0> VA<1>
+p1* is VC VA<0> VA<1>
+vc& is *VC *VA<0> *VA<1>
+p0 is *VC *VA<0> *VA<1>
+p1 is *VC *VA<0> *VA<1>
+nullptr is empty
+A is A
diff --git a/regression-tests/test-results/pure2-is-with-polymorphic-types.cpp b/regression-tests/test-results/pure2-is-with-polymorphic-types.cpp
@@ -0,0 +1,104 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+#line 1 "pure2-is-with-polymorphic-types.cpp2"
+class A;
+#line 2 "pure2-is-with-polymorphic-types.cpp2"
+
+template<int I> class VA;
+
+class VC;
+    
+
+#line 10 "pure2-is-with-polymorphic-types.cpp2"
+class VD;
+    
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+#line 1 "pure2-is-with-polymorphic-types.cpp2"
+class A {
+      public: A() = default;
+      public: A(A const&) = delete; /* No 'that' constructor, suppress copy */
+      public: auto operator=(A const&) -> void = delete;
+};
+#line 2 "pure2-is-with-polymorphic-types.cpp2"
+
+template<int I> class VA {
+public: virtual ~VA() noexcept;
+
+      public: VA() = default;
+      public: VA(VA const&) = delete; /* No 'that' constructor, suppress copy */
+      public: auto operator=(VA const&) -> void = delete;
+};
+#line 4 "pure2-is-with-polymorphic-types.cpp2"
+
+class VC: public VA<0>, public VA<1> {
+    public: VC() = default;
+    public: VC(VC const&) = delete; /* No 'that' constructor, suppress copy */
+    public: auto operator=(VC const&) -> void = delete;
+
+
+#line 8 "pure2-is-with-polymorphic-types.cpp2"
+};
+
+class VD: public VA<0> {
+    public: VD() = default;
+    public: VD(VD const&) = delete; /* No 'that' constructor, suppress copy */
+    public: auto operator=(VD const&) -> void = delete;
+
+
+#line 12 "pure2-is-with-polymorphic-types.cpp2"
+};
+
+auto fun(auto const& v, auto const& name) -> void;
+
+#line 29 "pure2-is-with-polymorphic-types.cpp2"
+auto main() -> int;
+
+//=== Cpp2 function definitions =================================================
+
+#line 1 "pure2-is-with-polymorphic-types.cpp2"
+
+
+template <int I> VA<I>::~VA() noexcept{}
+#line 14 "pure2-is-with-polymorphic-types.cpp2"
+auto fun(auto const& v, auto const& name) -> void{
+    std::cout << "" + cpp2::to_string(name) + " is";
+    if (cpp2::impl::is<VC>(v)) {std::cout << " VC";}
+    if (cpp2::impl::is<VA<0>>(v)) {std::cout << " VA<0>";}
+    if (cpp2::impl::is<VA<1>>(v)) {std::cout << " VA<1>";}
+    if (cpp2::impl::is<VD>(v)) {std::cout << " VD";}
+    if (cpp2::impl::is<VC*>(v)) {std::cout << " *VC";}
+    if (cpp2::impl::is<VA<0>*>(v)) {std::cout << " *VA<0>";}
+    if (cpp2::impl::is<VA<1>*>(v)) {std::cout << " *VA<1>";}
+    if (cpp2::impl::is<VD*>(v)) {std::cout << " *VD";}
+    if (cpp2::impl::is<void>(v)) {std::cout << " empty";}
+    if (cpp2::impl::is<A>(v)) {std::cout << " A";}
+    std::cout << std::endl;
+}
+
+#line 29 "pure2-is-with-polymorphic-types.cpp2"
+auto main() -> int{
+
+    VC vc {}; 
+    VA<0>* p0 {&vc}; 
+    VA<1>* p1 {&vc}; 
+
+    fun(vc, "vc");
+    fun(*cpp2::impl::assert_not_null(p0), "p0*");
+    fun(*cpp2::impl::assert_not_null(p1), "p1*");
+
+    fun(&vc, "vc&");
+    fun(cpp2::move(p0), "p0");
+    fun(cpp2::move(p1), "p1");
+
+    fun(nullptr, "nullptr");
+    fun(A(), "A");
+}
+
diff --git a/regression-tests/test-results/pure2-is-with-polymorphic-types.cpp2.output b/regression-tests/test-results/pure2-is-with-polymorphic-types.cpp2.output
@@ -0,0 +1,2 @@
+pure2-is-with-polymorphic-types.cpp2... ok (all Cpp2, passes safety checks)
+

Original file line number	Diff line number	Diff line change
`@@ -1635,39 +1635,44 @@ constexpr auto is( X&& ) {`
`1635`	`1635`	`// Types`
`1636`	`1636`	`//`
`1637`	`1637`	`template< typename C, typename X >`
`1638`		`-auto is( X const& x ) -> bool {`
	`1638`	`+constexpr auto is( X const& x ) -> auto {`
`1639`	`1639`	`if constexpr (`
`1640`	`1640`	`std::is_same_v<C, X>`
`1641`	`1641`	`\|\| std::is_base_of_v<C, X>`
`1642`	`1642`	`)`
`1643`	`1643`	`{`
`1644`		`- return true;`
	`1644`	`+ return std::true_type{};`
`1645`	`1645`	`}`
`1646`	`1646`	`else if constexpr (`
`1647`		`- std::is_base_of_v<X, C>`
`1648`		`- \|\| (`
`1649`		`- std::is_polymorphic_v<C>`
`1650`		`- && std::is_polymorphic_v<X>`
`1651`		`- )`
	`1647`	`+ std::is_polymorphic_v<C>`
	`1648`	`+ && std::is_polymorphic_v<X>`
`1652`	`1649`	`)`
`1653`	`1650`	`{`
`1654`		`- if constexpr (std::is_pointer_v<X>) {`
`1655`		`- return Dynamic_cast<C const*>(x) != nullptr;`
`1656`		`- }`
`1657`		`- else {`
`1658`		`- return Dynamic_cast<C const*>(&x) != nullptr;`
`1659`		`- }`
	`1651`	`+ return Dynamic_cast<C const*>(&x) != nullptr;`
`1660`	`1652`	`}`
`1661`	`1653`	`else if constexpr (`
`1662`		`- requires { *x; X(); }`
	`1654`	`+ (`
	`1655`	`+ std::is_same_v<X, std::nullptr_t>`
	`1656`	`+ \|\| requires { *x; X(); }`
	`1657`	`+ )`
`1663`	`1658`	`&& std::is_same_v<C, empty>`
`1664`	`1659`	`)`
`1665`	`1660`	`{`
`1666`	`1661`	`return x == X();`
`1667`	`1662`	`}`
`1668`		`- else {`
	`1663`	`+ else if constexpr (`
	`1664`	`+ std::is_pointer_v<C>`
	`1665`	`+ && std::is_pointer_v<X>`
	`1666`	`+ )`
	`1667`	`+ {`
	`1668`	`+ if (x != nullptr) {`
	`1669`	`+ return bool{is<std::remove_pointer_t<C>>(*x)};`
	`1670`	`+ }`
`1669`	`1671`	`return false;`
`1670`	`1672`	`}`
	`1673`	`+ else {`
	`1674`	`+ return std::false_type{};`
	`1675`	`+ }`
`1671`	`1676`	`}`
`1672`	`1677`
`1673`	`1678`