Here is a patch that implements the static operator[] paper.
One thing that doesn't work properly is the same problem as I've filed
yesterday for static operator() - PR107624 - that side-effects of
the postfix-expression on which the call or subscript operator are
applied are thrown away, I assume we have to add them into COMPOUND_EXPR
somewhere after we find out that the we've chosen a static member function
operator.
2022-11-15 Jakub Jelinek <jakub@redhat.com>
gcc/c-family/
* c-cppbuiltin.cc (c_cpp_builtins): Bump C++23
__cpp_multidimensional_subscript macro value to 202211L.
gcc/cp/
* decl.cc (grok_op_properties): Implement C++23 P2589R1
- static operator[]. Handle operator[] similarly to operator()
- allow static member functions, but pedwarn on it for C++20 and
older. Unlike operator(), perform rest of checks on it though for
C++20.
* call.cc (add_operator_candidates): For operator[] with class
typed first parameter, pass that parameter as first_arg and
an adjusted arglist without that parameter.
gcc/testsuite/
* g++.dg/cpp23/subscript9.C: New test.
* g++.dg/cpp23/feat-cxx2b.C: Expect a newer
__cpp_multidimensional_subscript value.
* g++.old-deja/g++.bugs/900210_10.C: Don't expect an error
for C++23 or later.
cpp_define (pfile, "__cpp_size_t_suffix=202011L");
cpp_define (pfile, "__cpp_if_consteval=202106L");
cpp_define (pfile, "__cpp_constexpr=202110L");
- cpp_define (pfile, "__cpp_multidimensional_subscript=202110L");
+ cpp_define (pfile, "__cpp_multidimensional_subscript=202211L");
cpp_define (pfile, "__cpp_named_character_escapes=202207L");
cpp_define (pfile, "__cpp_static_call_operator=202207L");
cpp_define (pfile, "__cpp_implicit_move=202207L");
if (fns == error_mark_node)
return error_mark_node;
if (fns)
- add_candidates (BASELINK_FUNCTIONS (fns),
- NULL_TREE, arglist, NULL_TREE,
- NULL_TREE, false,
- BASELINK_BINFO (fns),
- BASELINK_ACCESS_BINFO (fns),
- flags, candidates, complain);
+ {
+ if (code == ARRAY_REF)
+ {
+ vec<tree,va_gc> *restlist = make_tree_vector ();
+ for (unsigned i = 1; i < nargs; ++i)
+ vec_safe_push (restlist, (*arglist)[i]);
+ z_candidate *save_cand = *candidates;
+ add_candidates (BASELINK_FUNCTIONS (fns),
+ (*arglist)[0], restlist, NULL_TREE,
+ NULL_TREE, false,
+ BASELINK_BINFO (fns),
+ BASELINK_ACCESS_BINFO (fns),
+ flags, candidates, complain);
+ /* Release the vec if we didn't add a candidate that uses it. */
+ for (z_candidate *c = *candidates; c != save_cand; c = c->next)
+ if (c->args == restlist)
+ {
+ restlist = NULL;
+ break;
+ }
+ release_tree_vector (restlist);
+ }
+ else
+ add_candidates (BASELINK_FUNCTIONS (fns),
+ NULL_TREE, arglist, NULL_TREE,
+ NULL_TREE, false,
+ BASELINK_BINFO (fns),
+ BASELINK_ACCESS_BINFO (fns),
+ flags, candidates, complain);
+ }
}
/* Per [over.match.oper]3.2, if no operand has a class type, then
only non-member functions that have type T1 or reference to
an enumeration, or a reference to an enumeration. 13.4.0.6 */
if (! methodp || DECL_STATIC_FUNCTION_P (decl))
{
- if (operator_code == CALL_EXPR)
+ if (operator_code == TYPE_EXPR
+ || operator_code == COMPONENT_REF
+ || operator_code == NOP_EXPR)
+ {
+ error_at (loc, "%qD must be a non-static member function", decl);
+ return false;
+ }
+
+ if (operator_code == CALL_EXPR || operator_code == ARRAY_REF)
{
if (! DECL_STATIC_FUNCTION_P (decl))
{
}
if (cxx_dialect < cxx23
/* For lambdas we diagnose static lambda specifier elsewhere. */
- && ! LAMBDA_FUNCTION_P (decl)
+ && (operator_code == ARRAY_REF || ! LAMBDA_FUNCTION_P (decl))
/* For instantiations, we have diagnosed this already. */
&& ! DECL_USE_TEMPLATE (decl))
pedwarn (loc, OPT_Wc__23_extensions, "%qD may be a static member "
- "function only with %<-std=c++23%> or %<-std=gnu++23%>", decl);
- /* There are no further restrictions on the arguments to an
- overloaded "operator ()". */
- return true;
+ "function only with %<-std=c++23%> or %<-std=gnu++23%>",
+ decl);
}
- if (operator_code == TYPE_EXPR
- || operator_code == COMPONENT_REF
- || operator_code == ARRAY_REF
- || operator_code == NOP_EXPR)
- {
- error_at (loc, "%qD must be a non-static member function", decl);
- return false;
- }
-
- if (DECL_STATIC_FUNCTION_P (decl))
+ else if (DECL_STATIC_FUNCTION_P (decl))
{
error_at (loc, "%qD must be either a non-static member "
"function or a non-member function", decl);
return false;
}
-
- for (tree arg = argtypes; ; arg = TREE_CHAIN (arg))
- {
- if (!arg || arg == void_list_node)
- {
- if (complain)
- error_at(loc, "%qD must have an argument of class or "
- "enumerated type", decl);
- return false;
- }
+ else
+ for (tree arg = argtypes; ; arg = TREE_CHAIN (arg))
+ {
+ if (!arg || arg == void_list_node)
+ {
+ if (complain)
+ error_at (loc, "%qD must have an argument of class or "
+ "enumerated type", decl);
+ return false;
+ }
- tree type = non_reference (TREE_VALUE (arg));
- if (type == error_mark_node)
- return false;
-
- /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
- because these checks are performed even on template
- functions. */
- if (MAYBE_CLASS_TYPE_P (type)
- || TREE_CODE (type) == ENUMERAL_TYPE)
- break;
- }
+ tree type = non_reference (TREE_VALUE (arg));
+ if (type == error_mark_node)
+ return false;
+
+ /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
+ because these checks are performed even on template
+ functions. */
+ if (MAYBE_CLASS_TYPE_P (type)
+ || TREE_CODE (type) == ENUMERAL_TYPE)
+ break;
+ }
}
if (operator_code == CALL_EXPR)
#ifndef __cpp_multidimensional_subscript
# error "__cpp_multidimensional_subscript"
-#elif __cpp_multidimensional_subscript != 202110
-# error "__cpp_multidimensional_subscript != 202110"
+#elif __cpp_multidimensional_subscript != 202211
+# error "__cpp_multidimensional_subscript != 202211"
#endif
#ifndef __cpp_named_character_escapes
--- /dev/null
+// P2589R1
+// { dg-do run { target c++23 } }
+
+extern "C" void abort ();
+
+struct S
+{
+ S () {};
+ static int &operator[] () { return a[0]; }
+ static int &operator[] (int x) { return a[x]; }
+ static int &operator[] (int x, long y) { return a[x + y * 8]; }
+ static int a[64];
+};
+int S::a[64];
+
+int
+main ()
+{
+ S s;
+ for (int i = 0; i < 64; i++)
+ s.a[i] = 64 - i;
+ if (s[] != 64 || s[3] != 61 || s[4, 5] != 20)
+ abort ();
+ s[]++;
+ s[42]++;
+ ++s[3, 2];
+ if (s.a[0] != 65 || s.a[42] != 23 || s.a[19] != 46)
+ abort ();
+}
// keywords: operator[], static function members
struct struct0 {
- static int operator[] (); /* { dg-error "" } */
+ static int operator[] (); /* { dg-error "" "" { target c++20_down } } */
};
int main () { return 0; }
git://gcc.gnu.org / gcc.git / commitdiff