c++: Implement C++23 P2128R6 - Multidimensional subscript operator [PR102611]

The following patch implements the C++23 Multidimensional subscript operator
P2128R6 paper.
As C++20 and older only allow a single expression in between []s (albeit
for C++20 with a deprecation warning if it is a comma expression) and even
in C++23 and for the coming years I think the vast majority of subscript
expressions will still have a single expression and even in C++23 it is
quite special, as e.g. the builtin operator requires exactly one
assignment expression, the patch attempts to optimize for that case and
if possible not to slow down that common case (or use more memory for it).
So, already during parsing it differentiates between that (uses a single
index_exp tree in that case) and the new cases (zero or two+ expressions
in the list), for which it sets index_exp to NULL_TREE and uses a
releasing_vec instead similarly to how e.g. finish_call_expr uses it.
In call.c it introduces new functions build_op_subscript{,_1} which are
something in between build_new_op{,_1} and build_op_call{,_1}.
The former requires fixed number of arguments (and the patch still uses
it for the common case of subscript with exactly one index expression),
the latter handles variable number of arguments but is too CALL_EXPR specific
and handles various cases that are unnecessary for the subscript.
Right now the subscript for 0 or 2+ expressions doesn't need to deal with
builtin candidates and so is quite simple.

As discussed in the paper, for backwards compatibility, if for 2+ index
expressions build_op_subscript fails (called with tf_none) and the
expressions together form a valid comma expression (again checked with
tf_none), it is used that C++20-ish way with a pedwarn about it, but if
even that fails, build_op_subscript is called again with standard complain
flags to diagnose it in the new way.  And similarly for the builtin case.

The -Wcomma-subscript warning used to be enabled by default unless
-Wno-deprecated.  Since the C/C++98..20 behavior is no longer deprecated,
but ill-formed or changed meaning, it is now for C++23 enabled by
default regardless of -Wno-deprecated and controls the pedwarn (but not the
errors emitted if something wasn't valid before and isn't valid in C++23
either).

2021-11-25  Jakub Jelinek  <jakub@redhat.com>

	PR c++/102611
gcc/
	* doc/invoke.texi (-Wcomma-subscript): Document that for
	-std=c++20 the option isn't enabled by default with -Wno-deprecated
	but for -std=c++23 it is.
gcc/c-family/
	* c-opts.c (c_common_post_options): Enable -Wcomma-subscript by
	default for C++23 regardless of warn_deprecated.
	* c-cppbuiltin.c (c_cpp_builtins): Predefine
	__cpp_multidimensional_subscript=202110L for C++23.
gcc/cp/
	* cp-tree.h (build_op_subscript): Implement P2128R6
	- Multidimensional subscript operator.  Declare.
	(class releasing_vec): Add release method.
	(grok_array_decl): Remove bool argument, add vec<tree, va_gc> **
	and tsubst_flags_t arguments.
	(build_min_non_dep_op_overload): Declare another overload.
	* parser.c (cp_parser_parenthesized_expression_list_elt): New function.
	(cp_parser_postfix_open_square_expression): Mention C++23 syntax in
	function comment.  For C++23 parse zero or more than one initializer
	clauses in expression list, adjust grok_array_decl caller.
	(cp_parser_parenthesized_expression_list): Use
	cp_parser_parenthesized_expression_list_elt.
	(cp_parser_builtin_offsetof): Adjust grok_array_decl caller.
	* decl.c (grok_op_properties): For C++23 don't check number
	of arguments of operator[].
	* decl2.c (grok_array_decl): Remove decltype_p argument, add
	index_exp_list and complain arguments.  If index_exp is NULL,
	handle *index_exp_list as the subscript expression list.
	* tree.c (build_min_non_dep_op_overload): New overload.
	* call.c (add_operator_candidates, build_over_call): Adjust comments
	for removal of build_new_op_1.
	(build_op_subscript): New function.
	* pt.c (tsubst_copy_and_build_call_args): New function.
	(tsubst_copy_and_build) <case ARRAY_REF>: If second
	operand is magic CALL_EXPR with ovl_op_identifier (ARRAY_REF)
	as CALL_EXPR_FN, tsubst CALL_EXPR arguments including expanding
	pack expressions in it and call grok_array_decl instead of
	build_x_array_ref.
	<case CALL_EXPR>: Use tsubst_copy_and_build_call_args.
	* semantics.c (handle_omp_array_sections_1): Adjust grok_array_decl
	caller.
gcc/testsuite/
	* g++.dg/cpp2a/comma1.C: Expect different diagnostics for C++23.
	* g++.dg/cpp2a/comma3.C: Likewise.
	* g++.dg/cpp2a/comma4.C: Expect diagnostics for C++23.
	* g++.dg/cpp2a/comma5.C: Expect different diagnostics for C++23.
	* g++.dg/cpp23/feat-cxx2b.C: Test __cpp_multidimensional_subscript
	predefined macro.
	* g++.dg/cpp23/subscript1.C: New test.
	* g++.dg/cpp23/subscript2.C: New test.
	* g++.dg/cpp23/subscript3.C: New test.
	* g++.dg/cpp23/subscript4.C: New test.
	* g++.dg/cpp23/subscript5.C: New test.
	* g++.dg/cpp23/subscript6.C: New test.

1 files changed, 30 insertions, 1 deletions

diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index 7050a53abc2..7c58e23db3c 100644
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -3671,7 +3671,7 @@ build_min_non_dep_op_overload (enum tree_code op,
 	}
     }
   else
-   gcc_unreachable ();
+    gcc_unreachable ();
 
   va_end (p);
   call = build_min_non_dep_call_vec (non_dep, fn, args);
@@ -3685,6 +3685,35 @@ build_min_non_dep_op_overload (enum tree_code op,
   return call;
 }
 
+/* Similar to above build_min_non_dep_op_overload, but arguments
+   are taken from ARGS vector.  */
+
+tree
+build_min_non_dep_op_overload (tree non_dep, tree overload, tree object,
+			       vec<tree, va_gc> *args)
+{
+  non_dep = extract_call_expr (non_dep);
+
+  unsigned int nargs = call_expr_nargs (non_dep);
+  gcc_assert (TREE_CODE (TREE_TYPE (overload)) == METHOD_TYPE);
+  tree binfo = TYPE_BINFO (TREE_TYPE (object));
+  tree method = build_baselink (binfo, binfo, overload, NULL_TREE);
+  tree fn = build_min (COMPONENT_REF, TREE_TYPE (overload),
+		       object, method, NULL_TREE);
+  nargs--;
+  gcc_assert (vec_safe_length (args) == nargs);
+
+  tree call = build_min_non_dep_call_vec (non_dep, fn, args);
+
+  tree call_expr = extract_call_expr (call);
+  KOENIG_LOOKUP_P (call_expr) = KOENIG_LOOKUP_P (non_dep);
+  CALL_EXPR_OPERATOR_SYNTAX (call_expr) = true;
+  CALL_EXPR_ORDERED_ARGS (call_expr) = CALL_EXPR_ORDERED_ARGS (non_dep);
+  CALL_EXPR_REVERSE_ARGS (call_expr) = CALL_EXPR_REVERSE_ARGS (non_dep);
+
+  return call;
+}
+
 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX.  */
 
 vec<tree, va_gc> *