Message ID | Yaq52LN5jo5sZk4g@redhat.com |
---|---|
State | New |
Headers | show |
Series | [v2] c++: Handle auto(x) in parameter-declaration-clause [PR103401] | expand |
On 12/3/21 19:44, Marek Polacek wrote: > On Thu, Dec 02, 2021 at 12:56:38PM -0500, Jason Merrill wrote: >> On 12/2/21 10:27, Marek Polacek wrote: >>> On Wed, Dec 01, 2021 at 11:24:58PM -0500, Jason Merrill wrote: >>>> On 12/1/21 10:16, Marek Polacek wrote: >>>>> In C++23, auto(x) is valid, so decltype(auto(x)) should also be valid, >>>>> so >>>>> >>>>> void f(decltype(auto(0))); >>>>> >>>>> should be just as >>>>> >>>>> void f(int); >>>>> >>>>> but currently, everytime we see 'auto' in a parameter-declaration-clause, >>>>> we try to synthesize_implicit_template_parm for it, creating a new template >>>>> parameter list. The code above actually has us calling s_i_t_p twice; >>>>> once from cp_parser_decltype_expr -> cp_parser_postfix_expression which >>>>> fails and then again from cp_parser_decltype_expr -> cp_parser_expression. >>>>> So it looks like we have f<auto, auto> and we accept ill-formed code. >>>>> >>>>> So we need to be more careful about synthesizing the implicit template >>>>> parameter. cp_parser_postfix_expression looked like a sensible place. >>>> >>>> Does this cover other uses of auto in decltype, such as >>>> >>>> void f(decltype(new auto{0})); >>> >>> Yes: the clearing of auto_is_implicit_function_template_parm_p will happen here >>> too. >>> >>> However, I'm noticing this: >>> >>> void f1(decltype(new auto{0})); >>> void f2(decltype(new int{0})); >>> >>> void >>> g () >>> { >>> int i; >>> void f3(decltype(new auto{0})); >>> void f4(decltype(new int{0})); >>> f1 (&i); // error: no matching function for call to f1(int*) >>> // couldn't deduce template parameter auto:1 >>> f2 (&i); >>> f3 (&i); >>> f4 (&i); >>> } >>> I think the error we issue is bogus. (My patch doesn't change this. clang++ >>> accepts.) Should I file a PR (and investigate)? >> >> That certainly suggests that auto_is_implicit_function_template_parm_p isn't >> getting cleared soon enough for f1. > > Exactly right. > >>>> ? Should we adjust this flag in cp_parser_decltype along with all the other >>>> flags? >>> >>> I think that's possible, but wouldn't cover auto in default arguments, or array >>> bounds. >> >> I guess cp_parser_sizeof_operand would need the same change. >> >> Do we currently handle auto in default arguments wrong? Ah, I see that we >> currently set auto_is_... for the whole parameter declaration clause, rather >> than just for the decl-specifier-seq of parameters as the standard >> specifies: >> >> "A placeholder-type-specifier of the form type-constraint opt auto can be >> used as a decl-specifier of the decl-specifier-seq of a >> parameter-declaration of a function declaration or lambda-expression...." > > Thanks. How about this then? The patch gives the rationale. > > Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? > > -- >8 -- > In C++23, auto(x) is valid, so decltype(auto(x)) should also be valid, > so > > void f(decltype(auto(0))); > > should be just as > > void f(int); > > but currently, everytime we see 'auto' in a parameter-declaration-clause, > we try to synthesize_implicit_template_parm for it, creating a new template > parameter list. The code above actually has us calling s_i_t_p twice; > once from cp_parser_decltype_expr -> cp_parser_postfix_expression which > fails and then again from cp_parser_decltype_expr -> cp_parser_expression. > So it looks like we have f<auto, auto> and we accept ill-formed code. > > This shows that we need to be more careful about synthesizing the > implicit template parameter. [dcl.spec.auto.general] says that "A > placeholder-type-specifier of the form type-constraintopt auto can be > used as a decl-specifier of the decl-specifier-seq of a > parameter-declaration of a function declaration or lambda-expression..." > so this patch turns off auto_is_... after we've parsed the decl-specifier-seq. > > That doesn't quite cut yet though, because we also need to handle an > auto nested in the decl-specifier: > > void f(decltype(new auto{0})); > > therefore the cp_parser_decltype change. > > The second hunk broke lambda-generic-85713-2.C but I think the error we > issue with this patch is in fact correct, and clang++ agrees. > > The r11-1913 change is OK: we need to make sure that we see '(auto)' after > decltype to go ahead with 'decltype(auto)'. > > PR c++/103401 > > gcc/cp/ChangeLog: > > * parser.c (cp_parser_decltype): Clear > auto_is_implicit_function_template_parm_p. > (cp_parser_parameter_declaration): Clear > auto_is_implicit_function_template_parm_p after parsing the > decl-specifier-seq. > > gcc/testsuite/ChangeLog: > > * g++.dg/cpp1y/lambda-generic-85713-2.C: Add dg-error. > * g++.dg/cpp23/auto-fncast7.C: New test. > * g++.dg/cpp23/auto-fncast8.C: New test. > * g++.dg/cpp23/auto-fncast9.C: New test. > --- > gcc/cp/parser.c | 19 +++++++++++ > .../g++.dg/cpp1y/lambda-generic-85713-2.C | 2 +- > gcc/testsuite/g++.dg/cpp23/auto-fncast7.C | 9 +++++ > gcc/testsuite/g++.dg/cpp23/auto-fncast8.C | 34 +++++++++++++++++++ > gcc/testsuite/g++.dg/cpp23/auto-fncast9.C | 17 ++++++++++ > 5 files changed, 80 insertions(+), 1 deletion(-) > create mode 100644 gcc/testsuite/g++.dg/cpp23/auto-fncast7.C > create mode 100644 gcc/testsuite/g++.dg/cpp23/auto-fncast8.C > create mode 100644 gcc/testsuite/g++.dg/cpp23/auto-fncast9.C > > diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c > index 55e6a1a8b3a..7508def0750 100644 > --- a/gcc/cp/parser.c > +++ b/gcc/cp/parser.c > @@ -16432,6 +16432,16 @@ cp_parser_decltype (cp_parser *parser) > = parser->greater_than_is_operator_p; > parser->greater_than_is_operator_p = true; > > + /* Don't synthesize an implicit template type parameter here. This > + could happen with C++23 code like > + > + void f(decltype(new auto{0})); > + > + where we want to deduce the auto right away so that the parameter > + is of type 'int *'. */ > + auto cleanup = make_temp_override > + (parser->auto_is_implicit_function_template_parm_p, false); Please also make this change to cp_parser_sizeof_operand, and add tests involving sizeof/alignof in array bounds. OK with that change. > /* Do not actually evaluate the expression. */ > ++cp_unevaluated_operand; > > @@ -24668,6 +24678,15 @@ cp_parser_parameter_declaration (cp_parser *parser, > &decl_specifiers, > &declares_class_or_enum); > > + /* [dcl.spec.auto.general]: "A placeholder-type-specifier of the form > + type-constraint opt auto can be used as a decl-specifier of the > + decl-specifier-seq of a parameter-declaration of a function declaration > + or lambda-expression..." but we must not synthesize an implicit template > + type parameter in its declarator. That is, in "void f(auto[auto{10}]);" > + we want to synthesize only the first auto. */ > + auto cleanup = make_temp_override > + (parser->auto_is_implicit_function_template_parm_p, false); > + > /* Complain about missing 'typename' or other invalid type names. */ > if (!decl_specifiers.any_type_specifiers_p > && cp_parser_parse_and_diagnose_invalid_type_name (parser)) > diff --git a/gcc/testsuite/g++.dg/cpp1y/lambda-generic-85713-2.C b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-85713-2.C > index 8fb8dfdeaf0..dbc9e8c732c 100644 > --- a/gcc/testsuite/g++.dg/cpp1y/lambda-generic-85713-2.C > +++ b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-85713-2.C > @@ -2,6 +2,6 @@ > // { dg-do compile { target c++14 } } > > auto l4 = [](auto v, auto (&array (int)) [5]) -> int { return v + array[0]; }; > -auto l5 = [](auto v, auto (&array (auto)) [5]) -> int { return v + array[0]; }; > +auto l5 = [](auto v, auto (&array (auto)) [5]) -> int { return v + array[0]; }; // { dg-error ".auto. parameter not permitted in this context" } > auto l6 = [](auto v, auto (&array (int int)) [5]) -> int { return v + array[0]; }; // { dg-error "two or more data types" } > auto l7 = [](auto v, auto (&array (int auto)) [5]) -> int { return v + array[0]; }; // { dg-error "two or more data types" } > diff --git a/gcc/testsuite/g++.dg/cpp23/auto-fncast7.C b/gcc/testsuite/g++.dg/cpp23/auto-fncast7.C > new file mode 100644 > index 00000000000..763164f3e5b > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp23/auto-fncast7.C > @@ -0,0 +1,9 @@ > +// PR c++/103401 > +// { dg-do compile { target c++23 } } > + > +void f(decltype(auto(0))) { } > + > +int main() > +{ > + f<int,int>(0); // { dg-error "no matching function" } > +} > diff --git a/gcc/testsuite/g++.dg/cpp23/auto-fncast8.C b/gcc/testsuite/g++.dg/cpp23/auto-fncast8.C > new file mode 100644 > index 00000000000..4cf078ee989 > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp23/auto-fncast8.C > @@ -0,0 +1,34 @@ > +// PR c++/103401 > +// { dg-do compile { target c++23 } } > + > +void f1 (decltype(auto(0))); > +void f2 (decltype(auto{0})); > +void f3 (int = auto(42)); > +void f4 (int = auto{42}); > +void f5 (decltype(auto(0)) = auto(42)); > +void f6 (auto (x)); > +void f7 (int[auto(10)]); > +void f8 (int[auto{10}]); > +void f9 (auto[auto{10}]); > +void f10 (auto); > +void f11 (int x, decltype(x) y); > + > +void > +g () > +{ > + f1 (1); > + f2 (1); > + f3 (); > + f3 (1); > + f4 (); > + f4 (1); > + f5 (); > + f5 (1); > + f6 ('a'); > + int a[10]; > + f7 (&a[0]); > + f8 (&a[0]); > + f9 (&a[0]); > + f10 (1); > + f11 (1, 2); > +} > diff --git a/gcc/testsuite/g++.dg/cpp23/auto-fncast9.C b/gcc/testsuite/g++.dg/cpp23/auto-fncast9.C > new file mode 100644 > index 00000000000..12a0dcece75 > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp23/auto-fncast9.C > @@ -0,0 +1,17 @@ > +// PR c++/103401 > +// { dg-do compile { target c++23 } } > + > +void f1(decltype(new auto{0})); > +void f2(decltype(new int{0})); > + > +void > +g () > +{ > + int i; > + void f3(decltype(new auto{0})); > + void f4(decltype(new int{0})); > + f1 (&i); > + f2 (&i); > + f3 (&i); > + f4 (&i); > +} > > base-commit: bf548ce3e67276aa429b462cf41e68891fdf40c2 >
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index 55e6a1a8b3a..7508def0750 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -16432,6 +16432,16 @@ cp_parser_decltype (cp_parser *parser) = parser->greater_than_is_operator_p; parser->greater_than_is_operator_p = true; + /* Don't synthesize an implicit template type parameter here. This + could happen with C++23 code like + + void f(decltype(new auto{0})); + + where we want to deduce the auto right away so that the parameter + is of type 'int *'. */ + auto cleanup = make_temp_override + (parser->auto_is_implicit_function_template_parm_p, false); + /* Do not actually evaluate the expression. */ ++cp_unevaluated_operand; @@ -24668,6 +24678,15 @@ cp_parser_parameter_declaration (cp_parser *parser, &decl_specifiers, &declares_class_or_enum); + /* [dcl.spec.auto.general]: "A placeholder-type-specifier of the form + type-constraint opt auto can be used as a decl-specifier of the + decl-specifier-seq of a parameter-declaration of a function declaration + or lambda-expression..." but we must not synthesize an implicit template + type parameter in its declarator. That is, in "void f(auto[auto{10}]);" + we want to synthesize only the first auto. */ + auto cleanup = make_temp_override + (parser->auto_is_implicit_function_template_parm_p, false); + /* Complain about missing 'typename' or other invalid type names. */ if (!decl_specifiers.any_type_specifiers_p && cp_parser_parse_and_diagnose_invalid_type_name (parser)) diff --git a/gcc/testsuite/g++.dg/cpp1y/lambda-generic-85713-2.C b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-85713-2.C index 8fb8dfdeaf0..dbc9e8c732c 100644 --- a/gcc/testsuite/g++.dg/cpp1y/lambda-generic-85713-2.C +++ b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-85713-2.C @@ -2,6 +2,6 @@ // { dg-do compile { target c++14 } } auto l4 = [](auto v, auto (&array (int)) [5]) -> int { return v + array[0]; }; -auto l5 = [](auto v, auto (&array (auto)) [5]) -> int { return v + array[0]; }; +auto l5 = [](auto v, auto (&array (auto)) [5]) -> int { return v + array[0]; }; // { dg-error ".auto. parameter not permitted in this context" } auto l6 = [](auto v, auto (&array (int int)) [5]) -> int { return v + array[0]; }; // { dg-error "two or more data types" } auto l7 = [](auto v, auto (&array (int auto)) [5]) -> int { return v + array[0]; }; // { dg-error "two or more data types" } diff --git a/gcc/testsuite/g++.dg/cpp23/auto-fncast7.C b/gcc/testsuite/g++.dg/cpp23/auto-fncast7.C new file mode 100644 index 00000000000..763164f3e5b --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp23/auto-fncast7.C @@ -0,0 +1,9 @@ +// PR c++/103401 +// { dg-do compile { target c++23 } } + +void f(decltype(auto(0))) { } + +int main() +{ + f<int,int>(0); // { dg-error "no matching function" } +} diff --git a/gcc/testsuite/g++.dg/cpp23/auto-fncast8.C b/gcc/testsuite/g++.dg/cpp23/auto-fncast8.C new file mode 100644 index 00000000000..4cf078ee989 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp23/auto-fncast8.C @@ -0,0 +1,34 @@ +// PR c++/103401 +// { dg-do compile { target c++23 } } + +void f1 (decltype(auto(0))); +void f2 (decltype(auto{0})); +void f3 (int = auto(42)); +void f4 (int = auto{42}); +void f5 (decltype(auto(0)) = auto(42)); +void f6 (auto (x)); +void f7 (int[auto(10)]); +void f8 (int[auto{10}]); +void f9 (auto[auto{10}]); +void f10 (auto); +void f11 (int x, decltype(x) y); + +void +g () +{ + f1 (1); + f2 (1); + f3 (); + f3 (1); + f4 (); + f4 (1); + f5 (); + f5 (1); + f6 ('a'); + int a[10]; + f7 (&a[0]); + f8 (&a[0]); + f9 (&a[0]); + f10 (1); + f11 (1, 2); +} diff --git a/gcc/testsuite/g++.dg/cpp23/auto-fncast9.C b/gcc/testsuite/g++.dg/cpp23/auto-fncast9.C new file mode 100644 index 00000000000..12a0dcece75 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp23/auto-fncast9.C @@ -0,0 +1,17 @@ +// PR c++/103401 +// { dg-do compile { target c++23 } } + +void f1(decltype(new auto{0})); +void f2(decltype(new int{0})); + +void +g () +{ + int i; + void f3(decltype(new auto{0})); + void f4(decltype(new int{0})); + f1 (&i); + f2 (&i); + f3 (&i); + f4 (&i); +}