[clang] NFC: include non friendly types and missing sugar in test expectations

[mizvekov]

Summary

The dump of all diagnostics of all tests under clang/test/{CXX,SemaCXX,SemaTemplate} was analyzed , and all the cases where there were obviously bad canonical types being printed, like type-parameter-*-* and <overloaded function type> were identified. Also a small amount of cases of missing sugar were analyzed.

This patch then spells those explicitly in the test expectations, as preparatory work for future fixes for these problems.

Signed-off-by: Matheus Izvekov <[e-mail]>

[v.g.vassilev]

These changes will enable progress on https://reviews.llvm.org/D110216 They lgtm but let's hear from @rsmith.

[mizvekov]

rebase.

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p4-cxx14.cpp

 // RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx2b    %s
 // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20 %s
 // RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20 %s
 
 int a;
 int &b = [] (int &r) -> decltype(auto) { return r; } (a);
 int &c = [] (int &r) -> decltype(auto) { return (r); } (a);
 int &d = [] (int &r) -> auto & { return r; } (a);
 int &e = [] (int &r) -> auto { return r; } (a); // expected-error {{cannot bind to a temporary}}
-int &f = [] (int r) -> decltype(auto) { return r; } (a); // expected-error {{cannot bind to a temporary}}
+int &f = [] (int r) -> decltype(auto) { return r; } (a); // expected-error {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
 int &g = [] (int r) -> decltype(auto) { return (r); } (a); // expected-warning {{reference to stack}}
 // cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
 
 int test_explicit_auto_return()
 {
     struct X {};
     auto L = [](auto F, auto a) { return F(a); };
     auto M = [](auto a) -> auto { return a; }; // OK

clang/test/CXX/over/over.match/over.match.funcs/over.match.class.deduct/p2.cpp

template<typename T> struct initializer_list {
     const T *ptr;
     __SIZE_TYPE__ size;
     initializer_list();
   };
 }
 
 namespace p0702r1 {
   template<typename T> struct X { // expected-note {{candidate}}
-    X(std::initializer_list<T>); // expected-note {{candidate}}
+    X(std::initializer_list<T>); // expected-note {{candidate template ignored: could not match 'initializer_list<type-parameter-0-0>' against 'p0702r1::Z'}}
   };
 
   X xi = {0};
   X xxi = {xi};
   extern X<int> xi;
   // Prior to P0702R1, this is X<X<int>>.
   extern X<int> xxi;
 
int main() {
 
     static_assert(IsSame<decltype(opt), Optional<int>>::value);
     static_assert(IsSame<decltype(dupe), Optional<int>>::value);
     static_assert(!IsSame<decltype(dupe), Optional<Optional<int>>>::value);
   return 0;
 }
 
 
-}
+}
 

clang/test/CXX/stmt.stmt/stmt.iter/stmt.ranged/p1.cpp

struct F {
       void end(); // expected-note {{member is not a candidate because range type 'p0962r1::NF::F' has no 'begin' member}}
     };
     int *begin(F);
   }
 
   void use(NA::A a, NB::B b, NC::C c, ND::D d, NE::E e, NF::F f) {
     for (auto x : a) {}
     for (auto x : b) {}
-    for (auto x : c) {} // expected-error {{no viable 'end' function}}
-    for (auto x : d) {} // expected-error {{no viable 'begin' function}}
-    for (auto x : e) {} // expected-error {{no viable 'begin' function}}
-    for (auto x : f) {} // expected-error {{no viable 'end' function}}
+    for (auto x : c) {} // expected-error {{invalid range expression of type 'p0962r1::NC::C'; no viable 'end' function available}}
+    for (auto x : d) {} // expected-error {{invalid range expression of type 'p0962r1::ND::D'; no viable 'begin' function available}}
+    for (auto x : e) {} // expected-error {{invalid range expression of type 'p0962r1::NE::E'; no viable 'begin' function available}}
+    for (auto x : f) {} // expected-error {{invalid range expression of type 'p0962r1::NF::F'; no viable 'end' function available}}
   }
 }

clang/test/CXX/temp/temp.decls/temp.class.spec/p6.cpp

 template<class T> template<class T2> struct A<T>::C::B<T2*> { }; 
 
 A<short>::C::B<int*> absip;
 
 // Check for conflicts during template instantiation. 
 template<typename T, typename U>
 struct Outer {
   template<typename X, typename Y> struct Inner;
-  template<typename Y> struct Inner<T, Y> {}; // expected-note{{previous}}
+  template<typename Y> struct Inner<T, Y> {}; // expected-note{{previous declaration of class template partial specialization 'Inner<int, type-parameter-0-0>' is here}}
   template<typename Y> struct Inner<U, Y> {}; // expected-error{{cannot be redeclared}}
 };
 
 Outer<int, int> outer; // expected-note{{instantiation}}
 
 // Test specialization of class template partial specialization members.
 template<> template<typename Z>
 struct X0<float>::Inner0<Z*> {

clang/test/CXX/temp/temp.decls/temp.mem/p5.cpp

template<typename T> operator const T*() const {
     // cxx98_20-error{{cannot initialize return object of type 'const int *' with an lvalue of type 'int'}} \
     // cxx2b-error{{cannot initialize return object of type 'const char *' with an rvalue of type 'char'}} \
     // cxx2b-error{{cannot initialize return object of type 'const int *' with an rvalue of type 'int'}}
   }
 };
 
 template X0::operator const char*() const; // expected-note{{'X0::operator const char *<char>' requested here}}
 template X0::operator const int*(); // expected-note{{'X0::operator const int *<const int>' requested here}}
-template X0::operator float*() const; // expected-error{{explicit instantiation of undefined function template}}
+template X0::operator float*() const; // expected-error{{explicit instantiation of undefined function template 'operator type-parameter-0-0 *'}}
 
 void test_X0(X0 x0, const X0 &x0c) {
   x0.operator const int*(); // expected-note{{in instantiation of function template specialization}}
   x0.operator float *();
   x0c.operator const char*();
 }
 
 namespace PR14211 {

clang/test/CXX/temp/temp.decls/temp.variadic/multi-level-substitution.cpp

namespace PR13386 {
   template<typename...> struct tuple {};
   template<typename...T>
   struct S {
     template<typename...U>
     void f(T &&...t, U &&...u) {} // expected-note {{candidate}}
     template<typename...U>
     void g(U &&...u, T &&...t) {} // expected-note {{candidate}}
     template<typename...U>
-    void h(tuple<T, U> &&...) {} // expected-note 2{{candidate}}
+    void h(tuple<T, U> &&...) {}
+    // expected-note@-1 {{candidate template ignored: could not match 'tuple<type-parameter-0-0, type-parameter-0-0>' against 'int'}}
+    // expected-note@-2 {{candidate template ignored: substitution failure: deduced incomplete pack <(no value)> for template parameter 'U'}}
 
     template<typename...U>
     struct X {
       template<typename...V>
       void x(tuple<T, U, V> &&...); // expected-error {{different lengths}}
     };
   };
 

clang/test/SemaCXX/conversion-function.cpp

void f() {
     A<float, int> &af2 = E();
     const A<float, int> &caf2 = E();
   }
 
   // Check
   template<typename T>
   struct E2 {
     operator T
-    * // expected-error{{pointer to a reference}}
+    * // expected-error{{'operator type-parameter-0-0 *' declared as a pointer to a reference of type 'int &'}}
     () const;
   };
 
   E2<int&> e2i; // expected-note{{in instantiation}}
 }
 
 namespace crazy_declarators {
   struct A {

clang/test/SemaCXX/cxx1y-generic-lambdas-variadics.cpp

namespace variadic_expansion {
   }
 
   void h(int i, char c) { g(i, c); }
 }
 #endif
 
 namespace PR33082 {
   template<int ...I> void a() {
-    int arr[] = { [](auto ...K) { (void)I; } ... }; // expected-error {{no viable conversion}} expected-note {{candidate}}
+    int arr[] = { [](auto ...K) { (void)I; } ... };
+    // expected-error@-1   {{no viable conversion}}
+    // expected-note-re@-2 {{candidate template ignored: could not match 'auto (*)(type-parameter-0-0...){{.*}}' against 'int'}}
   }
 
   template<typename ...T> struct Pack {};
   template<typename ...T, typename ...U> void b(Pack<U...>, T ...t) {
     int arr[] = {[t...]() { // expected-error 2{{cannot initialize an array element of type 'int' with}}
       U u;
       return u;
     }()...};

clang/test/SemaCXX/cxx1y-generic-lambdas.cpp

 
 } // end ns
 
 namespace conversion_operator {
   void test() {
     auto L = [](auto a) -> int { return a; }; // expected-error {{cannot initialize}}
     int (*fp)(int) = L; 
     int (&fp2)(int) = [](auto a) { return a; };  // expected-error{{non-const lvalue}}
-    int (&&fp3)(int) = [](auto a) { return a; };  // expected-error{{no viable conversion}}\
-                                                  //expected-note{{candidate}}
+    int (&&fp3)(int) = [](auto a) { return a; };
+    // expected-error@-1   {{no viable conversion}}
+    // expected-note-re@-2 {{candidate template ignored: could not match 'auto (*)(type-parameter-0-0){{.*}}' against 'int (int)'}}
 
     using F = int(int);
     using G = int(void*);
     L.operator F*();
     L.operator G*(); // expected-note-re {{instantiation of function template specialization '{{.*}}::operator()<void *>'}}
 
     // Here, the conversion function is named 'operator auto (*)(int)', and
     // there is no way to write that name in valid C++.
int test() {
   };
   auto M = L(3);
   M(4.15);
  }
  
 {
   auto L = [](auto a) ->decltype(a) {
     print("a = ", a, "\n");
-    return [](auto b) ->decltype(a) { //expected-error{{no viable conversion}}\
-                                      //expected-note{{candidate template ignored}}
+    return [](auto b) ->decltype(a) {
+      // expected-error@-1   {{no viable conversion}}
+      // expected-note-re@-2 {{candidate template ignored: could not match 'int (*)(type-parameter-0-0){{.*}}' against 'int'}}
       print("b = ", b, "\n");
       return b;
     };
   };
   auto M = L(3); //expected-note{{in instantiation of}}
  }
 {
   auto L = [](auto a) {

clang/test/SemaCXX/cxx1z-decomposition.cpp

void enclosing() {
   struct R { int f() { return m; } };
   (void) [&] { return m; };
   (void) [m] {}; // expected-error {{'m' in capture list does not name a variable}}
 }
 
 void bitfield() {
   struct { int a : 3, : 4, b : 5; } a;
   auto &[x, y] = a;
-  auto &[p, q, r] = a; // expected-error {{decomposes into 2 elements, but 3 names were provided}}
+  auto &[p, q, r] = a; // expected-error-re {{type '(unnamed struct at {{.*}})' decomposes into 2 elements, but 3 names were provided}}
 }
 
 void for_range() {
   int x = 1;
   for (auto[a, b] : x) { // expected-error {{invalid range expression of type 'int'; no viable 'begin' function available}}
     a++;
   }
 

clang/test/SemaCXX/deduced-return-type-cxx14.cpp

namespace Templates {
   template<typename T> auto fwd_decl(); // expected-note {{declared here}}
   int e = fwd_decl<int>(); // expected-error {{cannot be used before it is defined}}
   template<typename T> auto fwd_decl() { return 0; }
   int f = fwd_decl<int>();
   template <typename T>
   auto fwd_decl(); // expected-note {{candidate template ignored: could not match 'auto ()' against 'int ()'}}
   int g = fwd_decl<char>();
 
-  auto (*p)() = f1; // expected-error {{incompatible initializer}}
+  auto (*p)() = f1; // expected-error {{variable 'p' with type 'auto (*)()' has incompatible initializer of type '<overloaded function type>'}}
   auto (*q)() = f1<int>; // ok
 
   typedef decltype(f2(1.2)) dbl; // cxx14_20-note {{previous}}
   // cxx2b-error@-1 {{no matching function for call to 'f2'}}
   typedef float dbl; // cxx14_20-error {{typedef redefinition with different types ('float' vs 'decltype(f2(1.2))' (aka 'double &'))}}
 
   extern template auto fwd_decl<double>();
   int k1 = fwd_decl<double>();

clang/test/SemaCXX/recovery-expr-type.cpp

 template <typename T = void *>
 struct S { // expected-note {{candidate}}
   S(T t);  // expected-note {{candidate}}
   ~S();
 };
 template <typename T> S(T t) -> S<void *>;
 
 void baz() {
-  bar(S(123)); // expected-error {{no matching conversion}}
+  bar(S(123)); // expected-error {{no matching conversion for functional-style cast from 'int' to 'test11::S<>'}}
 }
 } // namespace test11
 
 namespace test12 {
 // Verify we do not crash.
 int fun(int *foo = no_such_function()); // expected-error {{undeclared identifier}}
 void crash1() { fun(); }
 void crash2() { constexpr int s = fun(); }
 } // namespace test12

clang/test/SemaCXX/redeclared-alias-template.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 template<typename T> using A = int; // expected-note 2{{previous}}
 template<typename T> using A = char; // expected-error {{type alias template redefinition with different types ('char' vs 'int')}}
 template<typename T1, typename T2> using A = T1; // expected-error {{too many template parameters in template redeclaration}}
 
 template<typename T1, typename T2> using B = T1; // expected-note {{previous}}
-template<typename T2, typename T1> using B = T1; // expected-error {{type alias template redefinition with different types}}
+template<typename T2, typename T1> using B = T1; // expected-error {{type alias template redefinition with different types ('T1' (aka 'type-parameter-0-1') vs 'T1' (aka 'type-parameter-0-0'))}}
 
 
 template<typename> struct S;
 template<template<typename> class F> using FInt = F<int>;
 template<typename X> using SXRInt = FInt<S<X>::template R>;
 template<typename X> using SXRInt = typename S<X>::template R<int>; // ok, redeclaration.
 
 template<template<typename> class> struct TT;
 
 namespace FilterLookup {
   TT<A> f(); // expected-note {{previous declaration is here}}
 
   template<typename> using A = int;
   TT<A> f(); // expected-error {{functions that differ only in their return type cannot be overloaded}}
 }

clang/test/SemaTemplate/instantiate-var-template.cpp

namespace InstantiationDependent {
 
   template<int> constexpr int a = 1;
   template<typename T> constexpr T b = a<sizeof(sizeof(f(T())))>; // expected-error {{invalid application of 'sizeof' to an incomplete type 'void'}}
 
   static_assert(b<int> == 1, "");
   static_assert(b<char> == 1, ""); // expected-note {{in instantiation of}} expected-error {{not an integral constant}}
 
   template<typename T> void f() {
-    static_assert(a<sizeof(sizeof(f(T())))> == 0, ""); // expected-error {{static_assert failed}}
+    static_assert(a<sizeof(sizeof(f(T())))> == 0, ""); // expected-error {{static_assert failed due to requirement 'a<sizeof (sizeof (f(type-parameter-0-0())))> == 0'}}
   }
 }
 
 namespace PR24483 {
   template<typename> struct A;
   template<typename... T> A<T...> models;
   template<> struct B models<>; // expected-error {{incomplete type 'struct B'}} expected-note {{forward declaration}}
 }
 
 namespace InvalidInsertPos {
   template<typename T, int N> T v;
   template<int N> decltype(v<int, N-1>) v<int, N>;
   template<> int v<int, 0>;
   int k = v<int, 500>;
 }

clang/test/SemaTemplate/temp_arg_nontype.cpp

 
 namespace dependent_nested_partial_specialization {
   template<typename> using X = int; // expected-warning {{C++11}}
   template<typename T> using Y = T*; // expected-warning {{C++11}}
   int n;
 
   template<template<typename> class X> struct A {
     template<typename T, X<T> N> struct B; // expected-note 2{{here}}
-    template<typename T> struct B<T, 0> {}; // expected-error {{specializes a template parameter with dependent type 'Y<T>'}}
+    template<typename T> struct B<T, 0> {}; // expected-error {{non-type template argument specializes a template parameter with dependent type 'Y<T>' (aka 'type-parameter-0-0 *')}}
   };
   A<X>::B<int, 0> ax;
   A<Y>::B<int, &n> ay; // expected-error {{undefined}} expected-note {{instantiation of}}
 
   template<template<typename> class X> struct C {
     template<typename T, int N, int M> struct D; // expected-note {{here}}
     template<typename T, X<T> N> struct D<T*, N, N + 1> {}; // expected-error {{type of specialized non-type template argument depends on}}
   };

clang/test/SemaTemplate/temp_arg_nontype_cxx1z.cpp

namespace Function {
   typedef A<void (*)(), &f> a;
   typedef A<void (*)(), g> b;
   typedef A<void (*)(), &g> b;
   typedef A<void (*)(), h> c;
   typedef A<void (*)(), &h> c;
   typedef A<void (*)(), i> d;
   typedef A<void (*)(), &i> d;
   typedef A<void (*)(), i<>> d;
-  typedef A<void (*)(), i<int>> e; // expected-error {{is not implicitly convertible}}
+  typedef A<void (*)(), i<int>> e; // expected-error {{value of type '<overloaded function type>' is not implicitly convertible to 'void (*)()'}}
 
   typedef A<void (*)(), 0> x; // expected-error {{not allowed in a converted constant}}
   typedef A<void (*)(), nullptr> y;
 }
 
 void Func() {
   A<const char*, __func__> a; // expected-error {{pointer to subobject of predefined '__func__' variable}}
 }