Change cpp2::in closer to its original condition, closes #317

Restore a `pass_by_value` computation, but exclude class/union/array/function types. See comment thread in #317 for details.

Also don't allow the Cpp1 casts, and emit migration usability diagnostics for attempts to use them.

Author: hsutter

include/cpp2util.h

@@ -238,6 +238,7 @@
 
 namespace cpp2 {
 
+
 //-----------------------------------------------------------------------
 //
 //  Convenience names for fundamental types
@@ -519,9 +520,20 @@ template<typename T>
 //-----------------------------------------------------------------------
 //
 template<typename T>
+constexpr bool prefer_pass_by_value =
+    sizeof(T) <= 2*sizeof(void*)
+    && std::is_trivially_copy_constructible_v<T>
+    && !std::is_class_v<T>
+    && !std::is_union_v<T>
+    && !std::is_array_v<T>
+    && !std::is_function_v<T>
+    ;
+
+template<typename T>
+    requires (!std::is_void_v<T>)
 using in =
     std::conditional_t <
-        std::is_scalar_v<T>,
+        prefer_pass_by_value<T>,
         T const,
         T const&
     >;
@@ -1001,15 +1013,14 @@ auto as( X const& x ) -> C const& {
 }
 
 template< typename C, typename X >
-    requires (std::is_base_of_v<X, C> && !std::is_same_v<C,X>)
-auto as( X* x ) -> C* {
-    return Dynamic_cast<C*>(x);
-}
-
-template< typename C, typename X >
-    requires (std::is_base_of_v<X, C> && !std::is_same_v<C,X>)
-auto as( X const* x ) -> C const* {
-    return Dynamic_cast<C const*>(x);
+    requires (
+        std::is_pointer_v<C>
+        && std::is_pointer_v<X>
+        && std::is_base_of_v<CPP2_TYPEOF(*std::declval<X>()), CPP2_TYPEOF(*std::declval<C>())>
+        && !std::is_same_v<C, X>
+    )
+auto as( X x ) -> C {
+    return Dynamic_cast<C>(x);
 }
 
 

regression-tests/test-results/pure2-bounds-safety-pointer-arithmetic-error.cpp2.output

@@ -1,3 +1,3 @@
 pure2-bounds-safety-pointer-arithmetic-error.cpp2...
-pure2-bounds-safety-pointer-arithmetic-error.cpp2(15,13): error: 'delete' and owning raw pointers are not supported in Cpp2 - use unique.new<T>, shared.new<T>, or gc.new<T> instead (in that order)
+pure2-bounds-safety-pointer-arithmetic-error.cpp2(15,13): error: 'delete' and owning raw pointers are not supported in Cpp2 - use unique.new<T> or shared.new<T> instead in that order (or, in the future, gc.new<T>, but that is not yet implemented)
 

regression-tests/test-results/version

@@ -1,5 +1,5 @@
 
-cppfront compiler v0.2.1   Build 8522:0446
+cppfront compiler v0.2.1   Build 8529:1436
 Copyright(c) Herb Sutter   All rights reserved
 
 SPDX-License-Identifier: CC-BY-NC-ND-4.0

source/build.info

@@ -1 +1 @@
-"8522:0446"
+"8529:1436"

source/lex.h

@@ -1649,6 +1649,31 @@ auto lex_line(
                 //
                 else if (auto j = peek_is_keyword()) {
                     store(j, lexeme::Keyword);
+
+                    if (tokens.back() == "const_cast") {
+                        errors.emplace_back(
+                            source_position(lineno, i),
+                            "'const_cast' is not supported in Cpp2 - the current C++ best practice is to never cast away const, and that is const_cast's only effective use"
+                        );
+                    }
+                    if (tokens.back() == "reinterpret_cast") {
+                        errors.emplace_back(
+                            source_position(lineno, i),
+                            "'reinterpret_cast' is not supported in Cpp2 - use std::bit_cast instead"
+                        );
+                    }
+                    if (tokens.back() == "static_cast") {
+                        errors.emplace_back(
+                            source_position(lineno, i),
+                            "'static_cast<T>(val)' is not supported in Cpp2 - use 'val as T' for safe conversions instead, or if necessary unsafe_narrow<T>(val) for a possibly-lossy narrowing conversion"
+                        );
+                    }
+                    if (tokens.back() == "dynamic_cast") {
+                        errors.emplace_back(
+                            source_position(lineno, i),
+                            "'dynamic_cast<Derived*>(pBase)' is not supported in Cpp2 - use 'pBase as *Derived' for safe dynamic conversions instead"
+                        );
+                    }
                 }
 
                 //  Identifier
@@ -1675,13 +1700,13 @@ auto lex_line(
                         if (tokens.back() == "union") {
                             errors.emplace_back(
                                 source_position(lineno, i),
-                                "unsafe 'union's are not supported in Cpp2 - use std::variant instead (or, in the future, the Cpp2 'union' metaclass function, but that is not yet implemented)"
+                                "unsafe 'union' is not supported in Cpp2 - use std::variant instead (or, in the future, the Cpp2 'union' metaclass function, but that is not yet implemented)"
                             );
                         }
                         if (tokens.back() == "delete") {
                             errors.emplace_back(
                                 source_position(lineno, i),
-                                "'delete' and owning raw pointers are not supported in Cpp2 - use unique.new<T>, shared.new<T>, or gc.new<T> instead (in that order)"
+                                "'delete' and owning raw pointers are not supported in Cpp2 - use unique.new<T> or shared.new<T> instead in that order (or, in the future, gc.new<T>, but that is not yet implemented)"
                             );
                         }
                     }

source/reflect.h

@@ -596,7 +596,7 @@ namespace meta {
         std::deque<token>* generated_tokens_
     )
         : errors{ errors_ }
-        , errors_original_size{ static_cast<int>(std::ssize(*cpp2::assert_not_null(errors))) }
+        , errors_original_size{ cpp2::unsafe_narrow<int>(std::ssize(*cpp2::assert_not_null(errors))) }
         , generated_tokens{ generated_tokens_ }
         , parser{ *cpp2::assert_not_null(errors) }
 #line 45 "reflect.h2"

source/reflect.h2

@@ -44,7 +44,7 @@ compiler_services: @polymorphic_base @copyable type =
     )
     = {
         errors = errors_;
-        errors_original_size = static_cast<int>(std::ssize(errors*));
+        errors_original_size = cpp2::unsafe_narrow<int>(std::ssize(errors*));
         generated_tokens = generated_tokens_;
         parser = errors*;
     }