PR c++/90532 Ensure __is_constructible(T[]) is false

An array of an unknown bound is an incomplete type, so no object of such
a type can be constructed. This means __is_constructible should always
be false for an array of unknown bound.

This patch also changes the std::is_default_constructible trait to use
std::is_constructible, which now gives the right answer for arrays of
unknown bound.

gcc/cp:

	Backported from mainline
	2019-05-20  Jonathan Wakely  <jwakely@redhat.com>

	PR c++/90532 Ensure __is_constructible(T[]) is false
	* method.c (is_xible_helper): Return error_mark_node for construction
	of an array of unknown bound.

gcc/testsuite:

	Backported from mainline
	2019-05-20  Jonathan Wakely  <jwakely@redhat.com>

	PR c++/90532 Ensure __is_constructible(T[]) is false
	* g++.dg/ext/90532.C: New test.

libstdc++-v3:

	Backported from mainline
	2019-05-20  Jonathan Wakely  <jwakely@redhat.com>

	PR c++/90532 Ensure __is_constructible(T[]) is false
	* include/std/type_traits (__do_is_default_constructible_impl)
	(__is_default_constructible_atom, __is_default_constructible_safe):
	Remove.
	(is_default_constructible): Use is_constructible.
	* testsuite/20_util/is_constructible/value.cc: Check int[] case.
	* testsuite/20_util/is_default_constructible/value.cc: Likewise.
	* testsuite/20_util/is_trivially_constructible/value.cc: Likewise.
	* testsuite/20_util/is_trivially_default_constructible/value.cc:
	Likewise.

From-SVN: r271417

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 1503fd083ab53c43a4d1c1ec3f56deef62349ac6..7548b65589c028adeb187590c6771f05976b8b0a 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,12 @@
+2019-05-20  Jonathan Wakely  <jwakely@redhat.com>
+
+       Backported from mainline
+       2019-05-20  Jonathan Wakely  <jwakely@redhat.com>
+
+       PR c++/90532 Ensure __is_constructible(T[]) is false
+       * method.c (is_xible_helper): Return error_mark_node for construction
+       of an array of unknown bound.
+
 2019-05-17  Jakub Jelinek  <jakub@redhat.com>
 
        Backported from mainline

diff --git a/gcc/cp/method.c b/gcc/cp/method.c
index 03eea408a8fe94a780e0a5fc91463644b744c00f..74a1e8187a857e3fd6309bbc8bae0dc568830115 100644 (file)
--- a/gcc/cp/method.c
+++ b/gcc/cp/method.c
@@ -1205,6 +1205,8 @@ is_xible_helper (enum tree_code code, tree to, tree from, bool trivial)
     expr = assignable_expr (to, from);
   else if (trivial && from && TREE_CHAIN (from))
     return error_mark_node; // only 0- and 1-argument ctors can be trivial
+  else if (TREE_CODE (to) == ARRAY_TYPE && !TYPE_DOMAIN (to))
+    return error_mark_node; // can't construct an array of unknown bound
   else
     expr = constructible_expr (to, from);
   return expr;

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index ba936a8b8eea5dbb66fb7814a259f3e20bed4d91..ee9cb8d8e6ddd29cda80f39b237c07de7cd8bed5 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,11 @@
+2019-05-20  Jonathan Wakely  <jwakely@redhat.com>
+
+       Backported from mainline
+       2019-05-20  Jonathan Wakely  <jwakely@redhat.com>
+
+       PR c++/90532 Ensure __is_constructible(T[]) is false
+       * g++.dg/ext/90532.C: New test.
+
 2019-05-19  Paul Thomas  <pault@gcc.gnu.org>
 
        Backport from trunk

diff --git a/gcc/testsuite/g++.dg/ext/90532.C b/gcc/testsuite/g++.dg/ext/90532.C
new file mode 100644 (file)
index 0000000..acdc4e2
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/90532.C
@@ -0,0 +1,27 @@
+// { dg-do compile { target c++11 } }
+// PR c++/90532
+static_assert( !__is_constructible(int[]), "" );
+static_assert( !__is_constructible(int[], int), "" );
+static_assert( !__is_constructible(int[], int[]), "" );
+static_assert( !__is_trivially_constructible(int[]), "" );
+static_assert( !__is_trivially_constructible(int[], int), "" );
+static_assert( !__is_trivially_constructible(int[], int[]), "" );
+static_assert( !__is_trivially_constructible(int[], int(&)[]), "" );
+static_assert( !__is_trivially_constructible(int[], void), "" );
+struct A { };
+static_assert( !__is_constructible(A[]), "" );
+static_assert( !__is_constructible(A[], const A&), "" );
+static_assert( !__is_constructible(A[], const A[]), "" );
+static_assert( !__is_trivially_constructible(A[]), "" );
+static_assert( !__is_trivially_constructible(A[], const A&), "" );
+static_assert( !__is_trivially_constructible(A[], const A[]), "" );
+static_assert( !__is_trivially_constructible(A[], A(&)[]), "" );
+static_assert( !__is_trivially_constructible(A[], void), "" );
+struct B { B(); };
+static_assert( !__is_constructible(B[]), "" );
+static_assert( !__is_constructible(B[], const B&), "" );
+static_assert( !__is_trivially_constructible(B[]), "" );
+static_assert( !__is_trivially_constructible(B[], const B&), "" );
+static_assert( !__is_trivially_constructible(B[], const B[]), "" );
+static_assert( !__is_trivially_constructible(B[], B(&)[]), "" );
+static_assert( !__is_trivially_constructible(B[], void), "" );

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 0868a6fe060ad0bcc501eba31518771a60f25e89..e36154d14dc2920779f1194e91d06d730e434291 100644 (file)
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,19 @@
+2019-05-20  Jonathan Wakely  <jwakely@redhat.com>
+
+       Backported from mainline
+       2019-05-20  Jonathan Wakely  <jwakely@redhat.com>
+
+       PR c++/90532 Ensure __is_constructible(T[]) is false
+       * include/std/type_traits (__do_is_default_constructible_impl)
+       (__is_default_constructible_atom, __is_default_constructible_safe):
+       Remove.
+       (is_default_constructible): Use is_constructible.
+       * testsuite/20_util/is_constructible/value.cc: Check int[] case.
+       * testsuite/20_util/is_default_constructible/value.cc: Likewise.
+       * testsuite/20_util/is_trivially_constructible/value.cc: Likewise.
+       * testsuite/20_util/is_trivially_default_constructible/value.cc:
+       Likewise.
+
 2019-05-16  Jonathan Wakely  <jwakely@redhat.com>
 
        Backport from mainline

diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
index 1d14c751cfac79a48d70c31952c5d4ae39897cca..cc9cb2467a968adc4d8414c5380c9b9d9a9de84f 100644 (file)
--- a/libstdc++-v3/include/std/type_traits
+++ b/libstdc++-v3/include/std/type_traits
@@ -878,58 +878,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     : public __is_nt_destructible_safe<_Tp>::type
     { };
 
-  struct __do_is_default_constructible_impl
-  {
-    template<typename _Tp, typename = decltype(_Tp())>
-      static true_type __test(int);
-
-    template<typename>
-      static false_type __test(...);
-  };
-
-  template<typename _Tp>
-    struct __is_default_constructible_impl
-    : public __do_is_default_constructible_impl
-    {
-      typedef decltype(__test<_Tp>(0)) type;
-    };
-
-  template<typename _Tp>
-    struct __is_default_constructible_atom
-    : public __and_<__not_<is_void<_Tp>>,
-                    __is_default_constructible_impl<_Tp>>
-    { };
-
-  template<typename _Tp, bool = is_array<_Tp>::value>
-    struct __is_default_constructible_safe;
-
-  // The following technique is a workaround for a current core language
-  // restriction, which does not allow for array types to occur in
-  // functional casts of the form T().  Complete arrays can be default-
-  // constructed, if the element type is default-constructible, but
-  // arrays with unknown bounds are not.
-  template<typename _Tp>
-    struct __is_default_constructible_safe<_Tp, true>
-    : public __and_<__is_array_known_bounds<_Tp>,
-                   __is_default_constructible_atom<typename
-                      remove_all_extents<_Tp>::type>>
-    { };
-
-  template<typename _Tp>
-    struct __is_default_constructible_safe<_Tp, false>
-    : public __is_default_constructible_atom<_Tp>::type
+  /// is_constructible
+  template<typename _Tp, typename... _Args>
+    struct is_constructible
+      : public __bool_constant<__is_constructible(_Tp, _Args...)>
     { };
 
   /// is_default_constructible
   template<typename _Tp>
     struct is_default_constructible
-    : public __is_default_constructible_safe<_Tp>::type
-    { };
-
-  /// is_constructible
-  template<typename _Tp, typename... _Args>
-    struct is_constructible
-      : public __bool_constant<__is_constructible(_Tp, _Args...)>
+    : public is_constructible<_Tp>::type
     { };
 
   template<typename _Tp, bool = __is_referenceable<_Tp>::value>

diff --git a/libstdc++-v3/testsuite/20_util/is_constructible/value.cc b/libstdc++-v3/testsuite/20_util/is_constructible/value.cc
index acd7a5f5703a0b6f01d55748b214a558a87a3d7f..a8b40921d929ee67b26c9969e21002fcdf641efb 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/is_constructible/value.cc
+++ b/libstdc++-v3/testsuite/20_util/is_constructible/value.cc
@@ -35,4 +35,11 @@ void test01()
   static_assert(test_property<is_constructible, ExplicitClass>(false), "");
   static_assert(test_property<is_constructible, ExplicitClass,
                int, double>(false), "");
+  static_assert(test_property<is_constructible, int[]>(false), "PR c++/90532");
+  static_assert(test_property<is_constructible,
+               __gnu_test::construct::Empty[]>(false), "PR c++/90532");
+  static_assert(test_property<is_constructible,
+               __gnu_test::construct::Ukn[]>(false), "PR c++/90532");
+  static_assert(test_property<is_constructible,
+               __gnu_test::construct::nAny[]>(false), "PR c++/90532");
 }

diff --git a/libstdc++-v3/testsuite/20_util/is_default_constructible/value.cc b/libstdc++-v3/testsuite/20_util/is_default_constructible/value.cc
index bd66ed0ab92354c8d8a50c50d164fc5235f7804f..f6df45d841bc9f696e2c7ded411d3638a745a5ca 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/is_default_constructible/value.cc
+++ b/libstdc++-v3/testsuite/20_util/is_default_constructible/value.cc
@@ -138,3 +138,13 @@ static_assert(!std::is_default_constructible<DelCopy>::value, "Error");
 static_assert(!std::is_default_constructible<const DelCopy>::value, "Error");
 static_assert(!std::is_default_constructible<DelDtor>::value, "Error");
 static_assert(!std::is_default_constructible<const DelDtor>::value, "Error");
+
+static_assert(!std::is_default_constructible<int[]>::value, "PR c++/90532");
+static_assert(!std::is_default_constructible<Empty[]>::value, "PR c++/90532");
+static_assert(!std::is_default_constructible<B[]>::value, "PR c++/90532");
+static_assert(!std::is_default_constructible<D[]>::value, "PR c++/90532");
+static_assert(!std::is_default_constructible<U[]>::value, "PR c++/90532");
+static_assert(!std::is_default_constructible<Ukn[]>::value, "PR c++/90532");
+static_assert(!std::is_default_constructible<Ellipsis[]>::value, "PR c++/90532");
+static_assert(!std::is_default_constructible<Any[]>::value, "PR c++/90532");
+static_assert(!std::is_default_constructible<nAny[]>::value, "PR c++/90532");

diff --git a/libstdc++-v3/testsuite/20_util/is_trivially_constructible/value.cc b/libstdc++-v3/testsuite/20_util/is_trivially_constructible/value.cc
index 0c8ad62dbbce251551435d561ee1e8e15627e7d9..0979ceff7e37f686f8d6a5129ed8db9857c9f8ce 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/is_trivially_constructible/value.cc
+++ b/libstdc++-v3/testsuite/20_util/is_trivially_constructible/value.cc
@@ -180,4 +180,6 @@ void test01()
                MoveOnly, const MoveOnly&>(false), "");
   static_assert(test_property<is_trivially_constructible,
                MoveOnly2>(false), "");
+  static_assert(test_property<is_trivially_constructible,
+               int[]>(false), "PR c++/90532");
 }

diff --git a/libstdc++-v3/testsuite/20_util/is_trivially_default_constructible/value.cc b/libstdc++-v3/testsuite/20_util/is_trivially_default_constructible/value.cc
index 8baca915df31119386c3a3b250b413ea111d4528..f457721925d2e5758aa57a878d72d740ebda0c33 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/is_trivially_default_constructible/value.cc
+++ b/libstdc++-v3/testsuite/20_util/is_trivially_default_constructible/value.cc
@@ -62,4 +62,13 @@ void test01()
                construct::Nontrivial>(false), "");
   static_assert(test_category<is_trivially_default_constructible, 
                HasTemplateCtor>(true), "");
+
+  static_assert(test_category<is_trivially_default_constructible,
+               int[]>(false), "PR c++/90532");
+  struct A { };
+  static_assert(test_category<is_trivially_default_constructible,
+               A[]>(false), "PR c++/90532");
+  struct B { B() { } };
+  static_assert(test_category<is_trivially_default_constructible,
+               B[]>(false), "PR c++/90532");
 }