My r10-7705 patch for PR94521 made us set TFF_NO_FUNCTION_ARGUMENTS when
pretty printing the function scope of a local class type in order to
eliminate infinite recursion with a function signature that contains
decltype([]{}). But due to the way dump_function_decl works, this
change regressed our pretty printing of local class types whose context
contains a class template specialization, as in the testcase below, in
which we wrongly pretty print the two local types as 'A<T>::f<char>::S1'
and 'B<T>::f<int>::S2'.
This patch makes dump_scope pass TFF_NO_TEMPLATE_BINDINGS instead of
TFF_NO_FUNCTION_ARGUMENTS when pretty printing a function scope. It
appears this is the strictly better flag to use: it avoids the infinite
recursion issue, it restores pretty printing of the function parameter
list, and it stops dump_function_decl from trying to print a function
template specialization in its own weird way.
Summary of pretty printing differences for the below testcase:
r10-7704: A<T>::f() [with U = char; T = int]::S1
B<T>::f() [with T = int]::S2
r10-7705: A<T>::f<char>::S1
B<T>::f<int>::S2
this patch: A<int>::f<char>()::S1
B<int>::f()::S2
gcc/cp/ChangeLog:
PR c++/99213
PR c++/94521
* error.c (dump_scope): Pass TFF_NO_TEMPLATE_BINDINGS instead of
TFF_NO_FUNCTION_ARGUMENTS when dumping a function scope.
gcc/testsuite/ChangeLog:
PR c++/99213
PR c++/94521
* g++.dg/diagnostic/local1.C: New test.
}
else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
{
- if (DECL_USE_TEMPLATE (scope))
- f |= TFF_NO_FUNCTION_ARGUMENTS;
- dump_function_decl (pp, scope, f);
+ dump_function_decl (pp, scope, f | TFF_NO_TEMPLATE_BINDINGS);
pp_cxx_colon_colon (pp);
}
}
--- /dev/null
+// PR c++/99213
+// { dg-do compile { target c++14 } }
+
+template <class T>
+struct A {
+ template <class U>
+ static auto f() {
+ struct S1{};
+ return S1{};
+ }
+};
+
+using type = void;
+using type = decltype(A<int>::f<char>()); // { dg-error "A<int>::f<char>\\(\\)::S1" }
+
+template <class T>
+struct B {
+ static auto f() {
+ struct S2{};
+ return S2{};
+ }
+};
+
+using type = void;
+using type = decltype(B<int>::f()); // { dg-error "B<int>::f\\(\\)::S2" }