From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id 409333858D20 for ; Wed, 15 Nov 2023 23:18:39 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 409333858D20 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 409333858D20 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1700090321; cv=none; b=HTKp5T+0gW6TEVat56ljquYbnRLmgt1bHKZvdRFeg9QUyM9EB7Odw4EKO1PSKjnusLLmt9ufMUtoXSWy0HuJAeFd5G5Hpg1qmDvkyhWkowpJXqDUyvRTc7vhmEfh76LXIwFweO5kqDqYqcd6G0G74simbvxVR2T5HCSUc3idzLM= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1700090321; c=relaxed/simple; bh=FgSgoLXhW1ztQD+eYHHzyUUdHam+EYTShHdO86455kI=; h=DKIM-Signature:Message-ID:Date:MIME-Version:Subject:To:From; b=PVcyHm3eatJXNjDjeinaU6Vq11rB0xnMzsjU6Wl5K+ViobkIVRTigumBLX7PcZX98wUELPew+0ASBvVoPliQgpRN/1t0QJ1mkKfHApRpoLgV3KRiYIM/bYaPehoXZzow3KemgR5fF9tvA82W7WnEaHqIhevzFCCtaIWRsFJe6GY= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1700090318; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=xSQNfBN0T7VimOkWh3VLAivsZ3/zoU0g9/Sf31rJeOo=; b=OyNaOc4d3tkxnH1krlCQrDlp2AKD4lX2y9hW7Z5N662xgwb7cKLhniqgsEJpLIUZxj7jBQ CnR9Zn/XKhJ5S8toAF7pT7QUKGKGx3qURo0mw8bVXsSqK07m14aQCfzqF1lb1ZzhQJs4kj /L6i3v5OYleWT1BWW/Yca/dn7CWuUmI= Received: from mail-yw1-f200.google.com (mail-yw1-f200.google.com [209.85.128.200]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-222-CpHCzCAVOhmAg7M8BCUtDQ-1; Wed, 15 Nov 2023 18:18:37 -0500 X-MC-Unique: CpHCzCAVOhmAg7M8BCUtDQ-1 Received: by mail-yw1-f200.google.com with SMTP id 00721157ae682-5a909b4e079so2395677b3.2 for ; Wed, 15 Nov 2023 15:18:37 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1700090317; x=1700695117; h=content-transfer-encoding:in-reply-to:from:references:cc:to :content-language:subject:user-agent:mime-version:date:message-id :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=xSQNfBN0T7VimOkWh3VLAivsZ3/zoU0g9/Sf31rJeOo=; b=rmPRGW0cLwEk8aHUiPAeikGeD74Pjo2eB1uStiWClhxDq2/5IrAM+MCErNix2COsRe wmjWEseyzjWeMHH9vyr4uBHXkrrYTFPVQJ9A4K+h9hoT4GYw953IMxebCVJ8wRLvW2gG Aj8k1INLnz50T6kFXML2sYkBRSfuWJWC7XHI/hlM4EJ9X6lvYLuog1etoT+rcavIFgZV Akxey4wtXL3M9B5rAWYhsF5kUcsXPoUkZssVKq0s9Nj/IS/aq7157lDAqTE9UFsKqG7w Skr4tsqARwi1RDGM1eVHo+skQ/tnZkQy5UKdpb4U/4fSG9VMGQTIJhjQEdX6qlkbZa3+ v1IA== X-Gm-Message-State: AOJu0YxGSi6hSZ/IZ70zdsqY0WGI7GD3jFsXvN4ngWSqd2iEVSVkYi6J AXQ922c/yLRYBp38prAL5IAib4UNaJoR3OIH3n1s5oEtLiuhje2ed5r07ieakiSxMeVdgGjJBGC 254t2NnQtpJ7ZRi4NWw== X-Received: by 2002:a25:7710:0:b0:d7e:8175:4fa9 with SMTP id s16-20020a257710000000b00d7e81754fa9mr15171826ybc.4.1700090316845; Wed, 15 Nov 2023 15:18:36 -0800 (PST) X-Google-Smtp-Source: AGHT+IEFC3dw7glCrDKGYsGKA2X3GTU2aa4FVZcfRPGiRCNqnDWKGxVuwmEv6gzm0pyLdKv4nid4Sw== X-Received: by 2002:a25:7710:0:b0:d7e:8175:4fa9 with SMTP id s16-20020a257710000000b00d7e81754fa9mr15171804ybc.4.1700090316440; Wed, 15 Nov 2023 15:18:36 -0800 (PST) Received: from [192.168.1.108] (130-44-146-16.s12558.c3-0.arl-cbr1.sbo-arl.ma.cable.rcncustomer.com. [130.44.146.16]) by smtp.gmail.com with ESMTPSA id qc3-20020a05620a654300b0076d25b11b62sm3858644qkn.38.2023.11.15.15.18.34 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Wed, 15 Nov 2023 15:18:35 -0800 (PST) Message-ID: <73e3817f-5130-4f16-856c-e6f40ed57a71@redhat.com> Date: Wed, 15 Nov 2023 18:18:33 -0500 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v3] c++: fix parsing with auto(x) [PR112410] To: Marek Polacek Cc: GCC Patches References: <20231109195835.429291-1-polacek@redhat.com> <1c680274-040d-40d7-b998-b100084c0ba5@redhat.com> <5b947ae5-b4bb-4bf2-91b5-6dcace7b537d@redhat.com> From: Jason Merrill In-Reply-To: X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Language: en-US Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit X-Spam-Status: No, score=-12.4 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H3,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE,TXREP,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: On 11/15/23 17:24, Marek Polacek wrote: > On Tue, Nov 14, 2023 at 05:27:03PM -0500, Jason Merrill wrote: >> On 11/14/23 10:58, Marek Polacek wrote: >>> On Mon, Nov 13, 2023 at 09:26:41PM -0500, Jason Merrill wrote: >>>> On 11/10/23 20:13, Marek Polacek wrote: >>>>> On Thu, Nov 09, 2023 at 07:07:03PM -0500, Jason Merrill wrote: >>>>>> On 11/9/23 14:58, Marek Polacek wrote: >>>>>>> Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? >>>>>>> >>>>>>> -- >8 -- >>>>>>> Here we are wrongly parsing >>>>>>> >>>>>>> int y(auto(42)); >>>>>>> >>>>>>> which uses the C++23 cast-to-prvalue feature, and initializes y to 42. >>>>>>> However, we were treating the auto as an implicit template parameter. >>>>>>> >>>>>>> Fixing the auto{42} case is easy, but when auto is followed by a (, >>>>>>> I found the fix to be much more involved. For instance, we cannot >>>>>>> use cp_parser_expression, because that can give hard errors. It's >>>>>>> also necessary to disambiguate 'auto(i)' as 'auto i', not a cast. >>>>>>> auto(), auto(int), auto(f)(int), auto(*), auto(i[]), auto(...), etc. >>>>>>> are all function declarations. We have to look at more than one >>>>>>> token to decide. >>>>>> >>>>>> Yeah, this is a most vexing parse problem. The code is synthesizing >>>>>> template parameters before we've resolved whether the auto is a >>>>>> decl-specifier or not. >>>>>> >>>>>>> In this fix, I'm (ab)using cp_parser_declarator, with member_p=false >>>>>>> so that it doesn't commit. But it handles even more complicated >>>>>>> cases as >>>>>>> >>>>>>> int fn (auto (*const **&f)(int) -> char); >>>>>> >>>>>> But it doesn't seem to handle the extremely vexing >>>>>> >>>>>> struct A { >>>>>> A(int,int); >>>>>> }; >>>>>> >>>>>> int main() >>>>>> { >>>>>> int a; >>>>>> A b(auto(a), 42); >>>>>> } >>>>> >>>>> Argh. This test should indeed be accepted and is currently rejected, >>>>> but it's a different problem: 'b' is at block scope and you can't >>>>> have a template there. But when I put it into a namespace scope, >>>>> it shows that my patch doesn't work correctly. I've added auto-fncast14.C >>>>> for the latter and opened c++/112482 for the block-scope problem. >>>>>> I think we need to stop synthesizing immediately when we see RID_AUTO, and >>>>>> instead go back after we successfully parse a declaration and synthesize for >>>>>> any autos we saw along the way. :/ >>>>> >>>>> That seems very complicated :(. I had a different idea though; how >>>>> about the following patch? The idea is that if we see that parsing >>>>> the parameter-declaration-list didn't work, we undo what synthesize_ >>>>> did, and let cp_parser_initializer parse "(auto(42))", which should >>>>> succeed. I checked that after cp_finish_decl y is initialized to 42. >>>> >>>> Nice, that's much simpler. Do you also still need the changes to >>>> cp_parser_simple_type_specifier? >>> >>> I do, otherwise we parse >>> >>> int f (auto{42}); >>> >>> just as if it had been >>> >>> int f (auto); >>> >>> because the {42} is consumed in the cp_parser_simple_type_specifier/RID_AUTO >>> loop. :/ >> >> It isn't consumed there, that loop is just scanning forward to see if >> there's a ->. The { is still the next token when we expect it to be a >> closing ) in cp_parser_direct_declarator: > > Ok, the tokens are rolled back after consuming so we can... > >>> /* Parse the parameter-declaration-clause. */ >>> params >>> = cp_parser_parameter_declaration_clause (parser, flags); >>> const location_t parens_end >>> = cp_lexer_peek_token (parser->lexer)->location; >>> >>> /* Consume the `)'. */ >>> parens.require_close (parser); >> >> Maybe we want to abort_fully_implicit_template here rather than in >> cp_parser_parameter_declaration_clause? > > ...do this instead. Much better. > > Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? OK, thanks. > -- >8 -- > Here we are wrongly parsing > > int y(auto(42)); > > which uses the C++23 cast-to-prvalue feature, and initializes y to 42. > However, we were treating the auto as an implicit template parameter. > > Fixing the auto{42} case is easy, but when auto is followed by a (, > I found the fix to be much more involved. For instance, we cannot > use cp_parser_expression, because that can give hard errors. It's > also necessary to disambiguate 'auto(i)' as 'auto i', not a cast. > auto(), auto(int), auto(f)(int), auto(*), auto(i[]), auto(...), etc. > are all function declarations. > > This patch rectifies that by undoing the implicit function template > modification. In the test above, we should notice that the parameter > list is ill-formed, and since we've synthesized an implicit template > parameter, we undo it by calling abort_fully_implicit_template. Then, > we'll parse the "(auto(42))" as an initializer. > > PR c++/112410 > > gcc/cp/ChangeLog: > > * parser.cc (cp_parser_direct_declarator): Maybe call > abort_fully_implicit_template if it turned out the parameter list was > ill-formed. > > gcc/testsuite/ChangeLog: > > * g++.dg/cpp23/auto-fncast13.C: New test. > * g++.dg/cpp23/auto-fncast14.C: New test. > --- > gcc/cp/parser.cc | 13 +++++ > gcc/testsuite/g++.dg/cpp23/auto-fncast13.C | 61 ++++++++++++++++++++++ > gcc/testsuite/g++.dg/cpp23/auto-fncast14.C | 9 ++++ > 3 files changed, 83 insertions(+) > create mode 100644 gcc/testsuite/g++.dg/cpp23/auto-fncast13.C > create mode 100644 gcc/testsuite/g++.dg/cpp23/auto-fncast14.C > > diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc > index 5116bcb78f6..d1104336215 100644 > --- a/gcc/cp/parser.cc > +++ b/gcc/cp/parser.cc > @@ -23594,6 +23594,19 @@ cp_parser_direct_declarator (cp_parser* parser, > /* Consume the `)'. */ > parens.require_close (parser); > > + /* For code like > + int x(auto(42)); > + A a(auto(i), 42); > + we have synthesized an implicit template parameter and marked > + what we thought was a function as an implicit function template. > + But now, having seen the whole parameter list, we know it's not > + a function declaration, so undo that. */ > + if (cp_parser_error_occurred (parser) > + && parser->fully_implicit_function_template_p > + /* Don't do this for the inner (). */ > + && parser->default_arg_ok_p) > + abort_fully_implicit_template (parser); > + > /* If all went well, parse the cv-qualifier-seq, > ref-qualifier and the exception-specification. */ > if (member_p || cp_parser_parse_definitely (parser)) > diff --git a/gcc/testsuite/g++.dg/cpp23/auto-fncast13.C b/gcc/testsuite/g++.dg/cpp23/auto-fncast13.C > new file mode 100644 > index 00000000000..1bceffb70cf > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp23/auto-fncast13.C > @@ -0,0 +1,61 @@ > +// PR c++/112410 > +// { dg-do compile { target c++23 } } > + > +int f1 (auto(int) -> char); > +int f2 (auto x); > +int f3 (auto); > +int f4 (auto(i)); > + > +int v1 (auto(42)); > +int v2 (auto{42}); > +int e1 (auto{i}); // { dg-error "not declared" } > +int i; > +int v3 (auto{i}); > +int v4 (auto(i + 1)); > +int v5 (auto(+i)); > +int v6 (auto(i = 4)); > + > +int f5 (auto(i)); > +int f6 (auto()); > +int f7 (auto(int)); > +int f8 (auto(f)(int)); > +int f9 (auto(...) -> char); > +// FIXME: ICEs (PR c++/89867) > +//int f10 (auto(__attribute__((unused)) i)); > +int f11 (auto((i))); > +int f12 (auto(i[])); > +int f13 (auto(*i)); > +int f14 (auto(*)); > + > +int e2 (auto{}); // { dg-error "invalid use of .auto." } > +int e3 (auto(i, i)); // { dg-error "invalid use of .auto." } > + > +char bar (int); > +char baz (); > +char qux (...); > + > +void > +g (int i) > +{ > + f1 (bar); > + f2 (42); > + f3 (42); > + f4 (42); > + f5 (42); > + f6 (baz); > + f7 (bar); > + f8 (bar); > + f9 (qux); > +// f10 (42); > + f11 (42); > + f12 (&i); > + f13 (&i); > + f14 (&i); > + > + v1 = 1; > + v2 = 2; > + v3 = 3; > + v4 = 4; > + v5 = 5; > + v6 = 6; > +} > diff --git a/gcc/testsuite/g++.dg/cpp23/auto-fncast14.C b/gcc/testsuite/g++.dg/cpp23/auto-fncast14.C > new file mode 100644 > index 00000000000..9e7a06c87d5 > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp23/auto-fncast14.C > @@ -0,0 +1,9 @@ > +// PR c++/112410 > +// { dg-do compile { target c++23 } } > + > +struct A { > + A(int,int); > +}; > + > +int a; > +A b1(auto(a), 42); > > base-commit: 01bc30b222a9d2ff0269325d9e367f8f1fcef942