[v2] c++: Handle auto(x) in parameter-declaration-clause [PR103401]
Commit Message
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
base-commit: bf548ce3e67276aa429b462cf41e68891fdf40c2
Comments
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
>
@@ -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))
@@ -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" }
new file mode 100644
@@ -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" }
+}
new file mode 100644
@@ -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);
+}
new file mode 100644
@@ -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);
+}