c++: Implement P1009: Array size deduction in new-expressions.

This patch implements C++20 P1009, allowing code like

  new double[]{1,2,3}; // array bound will be deduced

Since this proposal makes the initialization rules more consistent, it is
applied to all previous versions of C++ (thus, effectively, all the way back
to C++11).

My patch is based on Jason's patch that handled the basic case.  I've
extended it to work with ()-init and also the string literal case.
Further testing revealed that to handle stuff like

  new int[]{t...};

in a template, we have to consider such a NEW_EXPR type-dependent.
Obviously, we first have to expand the pack to be able to deduce the
number of elements in the array.

Curiously, while implementing this proposal, I noticed that we fail
to accept

  new char[4]{"abc"};

so I've assigned 77841 to self.  I think the fix will depend on the
build_new_1 hunk in this patch.

The new tree.c function build_constructor_from_vec helps us morph
a vector into a CONSTRUCTOR more efficiently.

gcc/cp/ChangeLog:

	PR c++/93529
	* call.c (build_new_method_call_1): Use build_constructor_from_vec
	instead of build_tree_list_vec + build_constructor_from_list.
	* init.c (build_new_1): Handle new char[]{"foo"}.  Use
	build_constructor_from_vec instead of build_tree_list_vec +
	build_constructor_from_list.
	(build_new): Deduce the array size in new-expression if not
	present.  Handle ()-init.  Handle initializing an array from
	a string literal.
	* parser.c (cp_parser_new_type_id): Leave [] alone.
	(cp_parser_direct_new_declarator): Allow [].
	* pt.c (type_dependent_expression_p): In a NEW_EXPR, consider
	array types whose dimension has to be deduced type-dependent.

gcc/ChangeLog:

	PR c++/93529
	* tree.c (build_constructor_from_vec): New.
	* tree.h (build_constructor_from_vec): Declare.

gcc/testsuite/ChangeLog:

	PR c++/93529
	* g++.dg/cpp0x/sfinae4.C: Adjust expected result after P1009.
	* g++.dg/cpp2a/new-array1.C: New test.
	* g++.dg/cpp2a/new-array2.C: New test.
	* g++.dg/cpp2a/new-array3.C: New test.
	* g++.dg/cpp2a/new-array4.C: New test.

Co-authored-by: Jason Merrill <jason@redhat.com>

1 files changed, 51 insertions, 4 deletions

diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 872c234..360ab8c 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -3559,8 +3559,8 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
       else if (array_p)
 	{
 	  tree vecinit = NULL_TREE;
-	  if (vec_safe_length (*init) == 1
-	      && DIRECT_LIST_INIT_P ((**init)[0]))
+	  const size_t len = vec_safe_length (*init);
+	  if (len == 1 && DIRECT_LIST_INIT_P ((**init)[0]))
 	    {
 	      vecinit = (**init)[0];
 	      if (CONSTRUCTOR_NELTS (vecinit) == 0)
@@ -3578,6 +3578,15 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
 		  vecinit = digest_init (arraytype, vecinit, complain);
 		}
 	    }
+	  /* This handles code like new char[]{"foo"}.  */
+	  else if (len == 1
+		   && char_type_p (TYPE_MAIN_VARIANT (type))
+		   && TREE_CODE (tree_strip_any_location_wrapper ((**init)[0]))
+		      == STRING_CST)
+	    {
+	      vecinit = (**init)[0];
+	      STRIP_ANY_LOCATION_WRAPPER (vecinit);
+	    }
 	  else if (*init)
             {
               if (complain & tf_error)
@@ -3634,8 +3643,7 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
 		  && AGGREGATE_TYPE_P (type)
 		  && (*init)->length () > 1)
 		{
-		  ie = build_tree_list_vec (*init);
-		  ie = build_constructor_from_list (init_list_type_node, ie);
+		  ie = build_constructor_from_vec (init_list_type_node, *init);
 		  CONSTRUCTOR_IS_DIRECT_INIT (ie) = true;
 		  CONSTRUCTOR_IS_PAREN_INIT (ie) = true;
 		  ie = digest_init (type, ie, complain);
@@ -3917,6 +3925,45 @@ build_new (location_t loc, vec<tree, va_gc> **placement, tree type,
       return error_mark_node;
     }
 
+  /* P1009: Array size deduction in new-expressions.  */
+  if (TREE_CODE (type) == ARRAY_TYPE
+      && !TYPE_DOMAIN (type)
+      && *init)
+    {
+      /* This means we have 'new T[]()'.  */
+      if ((*init)->is_empty ())
+	{
+	  tree ctor = build_constructor (init_list_type_node, NULL);
+	  CONSTRUCTOR_IS_DIRECT_INIT (ctor) = true;
+	  vec_safe_push (*init, ctor);
+	}
+      tree &elt = (**init)[0];
+      /* The C++20 'new T[](e_0, ..., e_k)' case allowed by P0960.  */
+      if (!DIRECT_LIST_INIT_P (elt) && cxx_dialect >= cxx20)
+	{
+	  /* Handle new char[]("foo").  */
+	  if (vec_safe_length (*init) == 1
+	      && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
+	      && TREE_CODE (tree_strip_any_location_wrapper (elt))
+		 == STRING_CST)
+	    /* Leave it alone: the string should not be wrapped in {}.  */;
+	  else
+	    {
+	      tree ctor = build_constructor_from_vec (init_list_type_node, *init);
+	      CONSTRUCTOR_IS_DIRECT_INIT (ctor) = true;
+	      CONSTRUCTOR_IS_PAREN_INIT (ctor) = true;
+	      elt = ctor;
+	      /* We've squashed all the vector elements into the first one;
+		 truncate the rest.  */
+	      (*init)->truncate (1);
+	    }
+	}
+      /* Otherwise we should have 'new T[]{e_0, ..., e_k}'.  */
+      if (BRACE_ENCLOSED_INITIALIZER_P (elt))
+	elt = reshape_init (type, elt, complain);
+      cp_complete_array_type (&type, elt, /*do_default*/false);
+    }
+
   /* The type allocated must be complete.  If the new-type-id was
      "T[N]" then we are just checking that "T" is complete here, but
      that is equivalent, since the value of "N" doesn't matter.  */