1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s 2 3 template <class T> 4 struct only 5 { onlyonly6 only(T) {} 7 8 template <class U> onlyonly9 only(U) 10 { 11 static_assert(sizeof(U) == 0, "expected type failure"); 12 } 13 }; 14 f()15auto f() -> int 16 { 17 return 0; 18 } 19 20 auto g(); // expected-error{{return without trailing return type}} 21 22 int h() -> int; // expected-error{{trailing return type must specify return type 'auto', not 'int'}} 23 24 int i(); 25 auto i() -> int; i()26int i() {} 27 28 using T = auto (int) -> auto (*)(char) -> void; // expected-note {{previous}} 29 using T = void; // expected-error {{type alias redefinition with different types ('void' vs 'auto (int) -> auto (*)(char) -> void')}} 30 31 using U = auto (int) -> auto (*)(char) -> void; 32 using U = void (*(int))(char); // ok 33 34 int x; 35 36 template <class T> i(T x)37auto i(T x) -> decltype(x) 38 { 39 return x; 40 } 41 42 only<double> p1 = i(1.0); 43 44 template <class T> 45 struct X 46 { fX47 auto f(T x) -> T { return x; } 48 49 template <class U> gX50 auto g(T x, U y) -> decltype(x + y) 51 { 52 return x + y; 53 } 54 55 template<typename U> 56 struct nested { 57 template <class V> hX::nested58 auto h(T x, U y, V z) -> decltype(x + y + z) 59 { 60 return x + y + z; 61 } 62 }; 63 64 template<typename U> 65 nested<U> get_nested(); 66 }; 67 68 X<int> xx; 69 only<int> p2 = xx.f(0L); 70 only<double> p3 = xx.g(0L, 1.0); 71 only<double> p4 = xx.get_nested<double>().h(0L, 1.0, 3.14f); 72 73 namespace PR12053 { 74 template <typename T> f1(T t)75 auto f1(T t) -> decltype(f1(t)) {} // expected-note{{candidate template ignored}} 76 test_f1()77 void test_f1() { 78 f1(0); // expected-error{{no matching function for call to 'f1'}} 79 } 80 81 template <typename T> f2(T t)82 auto f2(T t) -> decltype(f2(&t)) {} // expected-note{{candidate template ignored}} 83 test_f2()84 void test_f2() { 85 f2(0); // expected-error{{no matching function for call to 'f2'}} 86 } 87 } 88