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()15 auto f() -> int
16 {
17 return 0;
18 }
19
20 auto g(); // expected-error{{return without trailing return type; deduced return types are a C++14 extension}}
21 decltype(auto) g2(); // expected-warning{{extension}} expected-error-re{{{{^}}deduced return types are a C++14 extension}}
22 auto badness = g2();
23
24 int h() -> int; // expected-error{{trailing return type must specify return type 'auto', not 'int'}}
25
26 int i();
27 auto i() -> int;
i()28 int i() {}
29
30 using T = auto (int) -> auto (*)(char) -> void; // expected-note {{previous}}
31 using T = void; // expected-error {{type alias redefinition with different types ('void' vs 'auto (int) -> auto (*)(char) -> void')}}
32
33 using U = auto (int) -> auto (*)(char) -> void;
34 using U = void (*(int))(char); // ok
35
36 int x;
37
38 template <class T>
i(T x)39 auto i(T x) -> decltype(x)
40 {
41 return x;
42 }
43
44 only<double> p1 = i(1.0);
45
46 template <class T>
47 struct X
48 {
fX49 auto f(T x) -> T { return x; }
50
51 template <class U>
gX52 auto g(T x, U y) -> decltype(x + y)
53 {
54 return x + y;
55 }
56
57 template<typename U>
58 struct nested {
59 template <class V>
hX::nested60 auto h(T x, U y, V z) -> decltype(x + y + z)
61 {
62 return x + y + z;
63 }
64 };
65
66 template<typename U>
67 nested<U> get_nested();
68 };
69
70 X<int> xx;
71 only<int> p2 = xx.f(0L);
72 only<double> p3 = xx.g(0L, 1.0);
73 only<double> p4 = xx.get_nested<double>().h(0L, 1.0, 3.14f);
74
75 namespace PR12053 {
76 template <typename T>
f1(T t)77 auto f1(T t) -> decltype(f1(t)) {} // expected-note{{candidate template ignored}}
78
test_f1()79 void test_f1() {
80 f1(0); // expected-error{{no matching function for call to 'f1'}}
81 }
82
83 template <typename T>
f2(T t)84 auto f2(T t) -> decltype(f2(&t)) {} // expected-note{{candidate template ignored}}
85
test_f2()86 void test_f2() {
87 f2(0); // expected-error{{no matching function for call to 'f2'}}
88 }
89 }
90
91 namespace DR1608 {
92 struct S {
93 void operator+();
94 int operator[](int);
95 auto f() -> decltype(+*this); // expected-note {{here}}
96 auto f() -> decltype((*this)[0]); // expected-error {{cannot be overloaded}}
97 };
98 }
99
100 namespace PR16273 {
101 struct A {
102 template <int N> void f();
103 auto g()->decltype(this->f<0>());
104 };
105 }
106
107 namespace PR46637 {
108 using A = auto () -> auto; // expected-error {{'auto' not allowed in function return type}}
109 using B = auto (*)() -> auto; // expected-error {{'auto' not allowed in function return type}}
110 template<auto (*)() -> auto> struct X {}; // expected-error {{'auto' not allowed in function return type}}
111 template<typename T> struct Y { T x; };
112 Y<auto() -> auto> y; // expected-error {{'auto' not allowed in function return type}}
113 }
114