OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

c++: error recovery during C++20 template-id ADL failure

Browse Source 
When diagnosing ADL failure we try to perform a second unqualified
lookup for backwards compatibility with legacy code (via -fpermissive),
and for better diagnostics.

But for C++20 template-id ADL, the backwards compatibility code
sometimes causes confusing subsequent diagnostics such as in the
testcase below where we end up diagnosing deduction failure after
emitting the helpful "no declarations were found by ADL".  This happens
because the code just discards the arguments of the template-id callee
when replacing it with the later-declared template, which leads to
overload resolution failure:

  <stdin>: In instantiation of ‘void f() [with T = int]’:
  <stdin>:12:22:   required from here
  <stdin>:5:9: error: ‘g’ was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation [-fpermissive]
  <stdin>:10:6: note: ‘template<class T> void g(int)’ declared here, later in the translation unit
  <stdin>:5:9: error: no matching function for call to ‘g(int)’
  <stdin>:10:6: note: candidate: ‘template<class T> void g(int)’
  <stdin>:10:6: note:   template argument deduction/substitution failed:
  <stdin>:5:9: note:   couldn’t deduce template parameter ‘T’

So for C++20 template-id ADL, this patch disables the backwards
compatibility code while keeping the helpful "no declarations were
found by ADL" diagnostic.

gcc/cp/ChangeLog:

	* pt.c (tsubst_copy_and_build) <case CALL_EXPR>: Disable the
	-fpermissive fallback for C++20 template-id ADL, but keep the
	diagnostic.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp2a/fn-template25.C: New test.
This commit is contained in:
Patrick Palka 2021-11-18 13:10:28 -05:00
parent 75ac95f664
commit 53c964ad99
2 changed files with 23 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
gcc/cp/pt.c
View File

@ -20439,7 +20439,8 @@ tsubst_copy_and_build (tree t,
(function, 1))))
&& !any_type_dependent_arguments_p (call_args))
{
if (TREE_CODE (function) == TEMPLATE_ID_EXPR)
bool template_id_p = (TREE_CODE (function) == TEMPLATE_ID_EXPR);
if (template_id_p)
function = TREE_OPERAND (function, 0);
if (koenig_p && (complain & tf_warning_or_error))
{
@ -20454,20 +20455,21 @@ tsubst_copy_and_build (tree t,
if (unq != function)
{
/* In a lambda fn, we have to be careful to not
introduce new this captures. Legacy code can't
be using lambdas anyway, so it's ok to be
stricter. */
bool in_lambda = (current_class_type
&& LAMBDA_TYPE_P (current_class_type));
char const *const msg
= G_("%qD was not declared in this scope, "
"and no declarations were found by "
"argument-dependent lookup at the point "
"of instantiation");
bool in_lambda = (current_class_type
&& LAMBDA_TYPE_P (current_class_type));
/* In a lambda fn, we have to be careful to not
introduce new this captures. Legacy code can't
be using lambdas anyway, so it's ok to be
stricter. Be strict with C++20 template-id ADL too. */
bool strict = in_lambda || template_id_p;
bool diag = true;
if (in_lambda)
if (strict)
error_at (cp_expr_loc_or_input_loc (t),
msg, function);
else
@ -20503,7 +20505,7 @@ tsubst_copy_and_build (tree t,
inform (DECL_SOURCE_LOCATION (fn),
"%qD declared here, later in the "
"translation unit", fn);
if (in_lambda)
if (strict)
RETURN (error_mark_node);
}

12
gcc/testsuite/g++.dg/cpp2a/fn-template25.C Normal file
View File

@ -0,0 +1,12 @@
// { dg-do compile { target c++20 } }
template<class T>
void f() {
g<int>(T{}); // { dg-error "argument-dependent lookup" }
// { dg-bogus "no match" "" { target *-*-* } .-1 }
}
template<class T>
void g(int); // { dg-message "declared here, later" }
template void f<int>();