blob: c219b77d9e4d520b6fd36d12f3bb7b505884ad8a (
about) (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
template <class T>
struct only
{
only(T) {}
template <class U>
only(U)
{
static_assert(sizeof(U) == 0, "expected type failure");
}
};
auto f() -> int
{
return 0;
}
auto g(); // expected-error{{return without trailing return type}}
int h() -> int; // expected-error{{trailing return type must specify return type 'auto', not 'int'}}
int i();
auto i() -> int;
int i() {}
using T = auto (int) -> auto (*)(char) -> void; // expected-note {{previous}}
using T = void; // expected-error {{type alias redefinition with different types ('void' vs 'auto (int) -> auto (*)(char) -> void')}}
using U = auto (int) -> auto (*)(char) -> void;
using U = void (*(int))(char); // ok
int x;
template <class T>
auto i(T x) -> decltype(x)
{
return x;
}
only<double> p1 = i(1.0);
template <class T>
struct X
{
auto f(T x) -> T { return x; }
template <class U>
auto g(T x, U y) -> decltype(x + y)
{
return x + y;
}
template<typename U>
struct nested {
template <class V>
auto h(T x, U y, V z) -> decltype(x + y + z)
{
return x + y + z;
}
};
template<typename U>
nested<U> get_nested();
};
X<int> xx;
only<int> p2 = xx.f(0L);
only<double> p3 = xx.g(0L, 1.0);
only<double> p4 = xx.get_nested<double>().h(0L, 1.0, 3.14f);
|
