From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 122989 invoked by alias); 10 Feb 2020 18:27:03 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 122041 invoked by uid 89); 10 Feb 2020 18:27:02 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-26.9 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,RCVD_IN_DNSWL_NONE autolearn=ham version=3.3.1 spammy= X-HELO: us-smtp-delivery-1.mimecast.com Received: from us-smtp-1.mimecast.com (HELO us-smtp-delivery-1.mimecast.com) (207.211.31.81) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 10 Feb 2020 18:27:00 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1581359219; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=CFls0tSKF/HbwWlnW7blpzMfwneiFfOJKAa9QtyxRVM=; b=aUML+gLid2WMzTh72JOGgg0kyLTdcqd2JJF+qpFKVJGMZF4XOHdKGN4U/ju46UWUY8dVJn yfdBr7zKYQbsduHMULlGj5UCmYHUkZoxp0eK46nVjMNGeFokRxziEGlo2sAFJrQVN557DO B06WLvvC3jPGrrc0YHPejxzhcRVPh7E= Received: from mail-wm1-f72.google.com (mail-wm1-f72.google.com [209.85.128.72]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-383-OFfCq900MFeWRG_6G0peGQ-1; Mon, 10 Feb 2020 13:26:57 -0500 Received: by mail-wm1-f72.google.com with SMTP id m4so96552wmi.5 for ; Mon, 10 Feb 2020 10:26:57 -0800 (PST) Return-Path: Received: from [10.0.27.69] ([193.85.242.99]) by smtp.gmail.com with ESMTPSA id r3sm1553269wrn.34.2020.02.10.10.26.54 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 10 Feb 2020 10:26:54 -0800 (PST) Subject: Re: [PATCH] c++: Fix return type deduction with an abbreviated function template To: Patrick Palka , gcc-patches@gcc.gnu.org References: <20200210132032.586931-1-ppalka@redhat.com> From: Jason Merrill Message-ID: Date: Mon, 10 Feb 2020 18:27:00 -0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.3.0 MIME-Version: 1.0 In-Reply-To: <20200210132032.586931-1-ppalka@redhat.com> X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit X-IsSubscribed: yes X-SW-Source: 2020-02/txt/msg00574.txt.bz2 On 2/10/20 2:20 PM, Patrick Palka wrote: > This patch fixes two issues with return type deduction in the presence of an > abbreviated function template. > > The first issue (PR 69448) is that if a placeholder auto return type contains > any modifiers such as & or *, then the abbreviated-function-template > compensation in splice_late_return_type does not get performed for the > underlying auto node, leading to incorrect return type deduction. This happens > because splice_late_return_type checks for a placeholder auto with is_auto, > which does not look through modifiers. This patch replaces the use of is_auto > with find_type_usage, but it first refactors find_type_usage to return a pointer > to the matched tree so that we next subsequently replace it. > > The second issue (PR 80471) is that the AUTO_IS_DECLTYPE flag is not being > preserved in splice_late_return_type when compensating for an abbreviated > function template, leading to us treating a decltype(auto) return type as if it > was an auto return type. Fixed by propagating AUTO_IS_DECLTYPE. The test for > PR 80471 is adjusted to expect the correct behavior. The comment in make_constrained_decltype_auto suggests that we should set AUTO_IS_DECLTYPE in make_auto_1 if name == decltype_auto_identifier; then callers won't need to worry about it. > Bootstrapped and regtested on x86_64-pc-linux-gnu, is this OK to commit? > > gcc/cp/ChangeLog: > > PR c++/69448 > PR c++/80471 > * type-utils.h (find_type_usage): Refactor to take a tree * and to > return a tree *, and update documentation accordingly. > * pt.c (splice_late_return_type): Use find_type_usage to find and > replace a possibly nested auto node. Preserve the AUTO_IS_DECLTYPE > flag when replacing the node. > (type_uses_auto): Adjust the call to find_type_usage. > > gcc/testsuite/ChangeLog: > > PR c++/69448 > PR c++/80471 > * g++.dg/concepts/abbrev3.C: New test. > * g++.dg/cpp2a/concepts-pr80471.C: Adjust a static_assert to expect the > correct behavior. > --- > gcc/cp/pt.c | 26 ++++++++++++------- > gcc/cp/type-utils.h | 26 +++++++++---------- > gcc/testsuite/g++.dg/concepts/abbrev3.C | 11 ++++++++ > gcc/testsuite/g++.dg/cpp2a/concepts-pr80471.C | 2 +- > 4 files changed, 41 insertions(+), 24 deletions(-) > create mode 100644 gcc/testsuite/g++.dg/concepts/abbrev3.C > > diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c > index 2fb52caa5d4..c83aaa7c7e1 100644 > --- a/gcc/cp/pt.c > +++ b/gcc/cp/pt.c > @@ -28904,17 +28904,21 @@ do_auto_deduction (tree type, tree init, tree auto_node, > tree > splice_late_return_type (tree type, tree late_return_type) > { > - if (is_auto (type)) > - { > - if (late_return_type) > - return late_return_type; > + if (is_auto (type) && late_return_type) > + return late_return_type; It occurs to me that we could just check late_return_type here, maybe change the is_auto test to an assert. > > - tree idx = get_template_parm_index (type); > + if (tree *auto_node = find_type_usage (&type, is_auto)) > + { > + tree idx = get_template_parm_index (*auto_node); > if (TEMPLATE_PARM_LEVEL (idx) <= processing_template_decl) > - /* In an abbreviated function template we didn't know we were dealing > - with a function template when we saw the auto return type, so update > - it to have the correct level. */ > - return make_auto_1 (TYPE_IDENTIFIER (type), true); > + { > + /* In an abbreviated function template we didn't know we were dealing > + with a function template when we saw the auto return type, so > + update it to have the correct level. */ > + tree new_node = make_auto_1 (TYPE_IDENTIFIER (*auto_node), true); > + AUTO_IS_DECLTYPE (new_node) = AUTO_IS_DECLTYPE (*auto_node); > + *auto_node = new_node; > + } > } > return type; > } > @@ -28960,8 +28964,10 @@ type_uses_auto (tree type) > else > return NULL_TREE; > } > + else if (tree *tp = find_type_usage (&type, is_auto)) > + return *tp; > else > - return find_type_usage (type, is_auto); > + return NULL_TREE; > } > > /* Report ill-formed occurrences of auto types in ARGUMENTS. If > diff --git a/gcc/cp/type-utils.h b/gcc/cp/type-utils.h > index 680b2497a36..4ad0d822119 100644 > --- a/gcc/cp/type-utils.h > +++ b/gcc/cp/type-utils.h > @@ -20,36 +20,36 @@ along with GCC; see the file COPYING3. If not see > #ifndef GCC_CP_TYPE_UTILS_H > #define GCC_CP_TYPE_UTILS_H > > -/* Returns the first tree within T that is directly matched by PRED. T may be a > - type or PARM_DECL and is incrementally decomposed toward its type-specifier > - until a match is found. NULL_TREE is returned if PRED does not match any > - part of T. > +/* Returns a pointer to the first tree within *TP that is directly matched by > + PRED. *TP may be a type or PARM_DECL and is incrementally decomposed toward > + its type-specifier until a match is found. NULL is returned if PRED does not > + match any part of *TP. > > - This is primarily intended for detecting whether T uses `auto' or a concept > + This is primarily intended for detecting whether *TP uses `auto' or a concept > identifier. Since either of these can only appear as a type-specifier for > the declaration in question, only top-level qualifications are traversed; > find_type_usage does not look through the whole type. */ > > -inline tree > -find_type_usage (tree t, bool (*pred) (const_tree)) > +inline tree * > +find_type_usage (tree *tp, bool (*pred) (const_tree)) > { > - enum tree_code code; > + tree t = *tp; > if (pred (t)) > - return t; > + return tp; > > - code = TREE_CODE (t); > + enum tree_code code = TREE_CODE (t); > > if (code == POINTER_TYPE || code == REFERENCE_TYPE > || code == PARM_DECL || code == OFFSET_TYPE > || code == FUNCTION_TYPE || code == METHOD_TYPE > || code == ARRAY_TYPE) > - return find_type_usage (TREE_TYPE (t), pred); > + return find_type_usage (&TREE_TYPE (t), pred); > > if (TYPE_PTRMEMFUNC_P (t)) > return find_type_usage > - (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (t)), pred); > + (&TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (t)), pred); > > - return NULL_TREE; > + return NULL; > } > > #endif // GCC_CP_TYPE_UTILS_H > diff --git a/gcc/testsuite/g++.dg/concepts/abbrev3.C b/gcc/testsuite/g++.dg/concepts/abbrev3.C > new file mode 100644 > index 00000000000..ba2a648156e > --- /dev/null > +++ b/gcc/testsuite/g++.dg/concepts/abbrev3.C > @@ -0,0 +1,11 @@ > +// PR c++/69448 > +// { dg-do compile { target c++14 } } > +// { dg-additional-options "-fconcepts" } > + > +long x; > + > +auto& f(auto) { return x; } > +auto* g(auto) { return &x; } > + > +long& r = f(1); > +long* p = g(1); > diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-pr80471.C b/gcc/testsuite/g++.dg/cpp2a/concepts-pr80471.C > index d5fa5a536d3..6ea6164b417 100644 > --- a/gcc/testsuite/g++.dg/cpp2a/concepts-pr80471.C > +++ b/gcc/testsuite/g++.dg/cpp2a/concepts-pr80471.C > @@ -18,6 +18,6 @@ int main() > { > int i; > static_assert(is_same< decltype(f(i)), int& >, ""); > - static_assert(is_same< decltype(g(i)), int >, ""); > + static_assert(is_same< decltype(g(i)), int& >, ""); > static_assert(is_same< decltype(z(i)), int& >, ""); > } >