From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2122) id 9A884385C407; Fri, 1 Jul 2022 14:51:39 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 9A884385C407 MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Jason Merrill To: gcc-cvs@gcc.gnu.org Subject: [gcc r13-1390] c++: dependent generic lambda template-id [PR106024] X-Act-Checkin: gcc X-Git-Author: Jason Merrill X-Git-Refname: refs/heads/master X-Git-Oldrev: 63abe04999283582b258adf60da6c19d541ebc68 X-Git-Newrev: 07ac550393d00fcadcee21b44abee6bb30c93949 Message-Id: <20220701145139.9A884385C407@sourceware.org> Date: Fri, 1 Jul 2022 14:51:39 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 01 Jul 2022 14:51:39 -0000 https://gcc.gnu.org/g:07ac550393d00fcadcee21b44abee6bb30c93949 commit r13-1390-g07ac550393d00fcadcee21b44abee6bb30c93949 Author: Jason Merrill Date: Thu Jun 23 23:14:35 2022 -0400 c++: dependent generic lambda template-id [PR106024] We were wrongly looking up the generic lambda op() in a dependent scope, and then trying to look up its instantiation at substitution time, but lambdas aren't instantiated, so we crashed. The fix is to not look into dependent class scopes. But this created trouble with wrongly trying to use a template from the enclosing scope when we aren't actually looking at a template-argument-list, in template/lookup18.C, so let's avoid that. PR c++/106024 gcc/cp/ChangeLog: * parser.cc (missing_template_diag): Factor out... (cp_parser_id_expression): ...from here. (cp_parser_lookup_name): Don't look in dependent object_type. gcc/testsuite/ChangeLog: * g++.dg/cpp2a/lambda-generic10.C: New test. Diff: --- gcc/cp/parser.cc | 23 ++++++++++++++++++++++- gcc/testsuite/g++.dg/cpp2a/lambda-generic10.C | 14 ++++++++++++++ 2 files changed, 36 insertions(+), 1 deletion(-) diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index da2f370cdca..357fde557c7 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -30676,9 +30676,11 @@ cp_parser_lookup_name (cp_parser *parser, tree name, } else if (object_type) { + bool dep = dependent_scope_p (object_type); + /* Look up the name in the scope of the OBJECT_TYPE, unless the OBJECT_TYPE is not a class. */ - if (CLASS_TYPE_P (object_type)) + if (!dep && CLASS_TYPE_P (object_type)) /* If the OBJECT_TYPE is a template specialization, it may be instantiated during name lookup. In that case, errors may be issued. Even if we rollback the current tentative @@ -30702,6 +30704,25 @@ cp_parser_lookup_name (cp_parser *parser, tree name, : is_template ? LOOK_want::TYPE : prefer_type_arg (tag_type)); + /* If we did unqualified lookup of a dependent member-qualified name and + found something, do we want to use it? P1787 clarified that we need + to look in the object scope first even if it's dependent, but for now + let's still use it in some cases. + FIXME remember unqualified lookup result to use if member lookup fails + at instantiation time. */ + if (decl && dep && is_template) + { + saved_token_sentinel toks (parser->lexer, STS_ROLLBACK); + /* Only use the unqualified class template lookup if we're actually + looking at a template arg list. */ + if (!cp_parser_skip_entire_template_parameter_list (parser)) + decl = NULL_TREE; + /* And only use the unqualified lookup if we're looking at ::. */ + if (decl + && !cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)) + decl = NULL_TREE; + } + /* If we know we're looking for a type (e.g. A in p->A::x), mock up a typename. */ if (!decl && object_type && tag_type != none_type diff --git a/gcc/testsuite/g++.dg/cpp2a/lambda-generic10.C b/gcc/testsuite/g++.dg/cpp2a/lambda-generic10.C new file mode 100644 index 00000000000..47a87bbfbd7 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/lambda-generic10.C @@ -0,0 +1,14 @@ +// PR c++/106024 +// { dg-do compile { target c++20 } } + +void sink(...); +template void f() +{ + sink ([] (int...) { return 1; } + .operator()(args...)...); // { dg-warning "-Wmissing-template-keyword" } +} // { dg-prune-output {expected '\)'} } + +int main() +{ + f<1,2,3>(); +}