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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -Wno-c99-designator %s
// PR5290
int const f0();
void f0_test() {
decltype(0, f0()) i = 0;
i = 0;
}
struct A { int a[1]; A() { } };
typedef A const AC;
int &f1(int*);
float &f2(int const*);
void test_f2() {
float &fr = f2(AC().a);
}
template <class T>
struct Future {
explicit Future(T v);
template <class F>
auto call(F&& fn) -> decltype(fn(T())) {
return fn(T());
}
template <class B, class F>
auto then(F&& fn) -> decltype(call(fn))
{
return fn(T());
}
};
void rdar16527205() {
Future<int> f1(42);
f1.call([](int){ return Future<float>(0); });
}
namespace pr10154 {
class A{
A(decltype(nullptr) param);
};
}
template<typename T> struct S {};
template<typename T> auto f(T t) -> decltype(S<int>(t)) {
using U = decltype(S<int>(t));
using U = S<int>;
return S<int>(t);
}
struct B {
B(decltype(undeclared)); // expected-error {{undeclared identifier}}
};
struct C {
C(decltype(undeclared; // expected-error {{undeclared identifier}} \
// expected-error {{expected ')'}} expected-note {{to match this '('}}
};
namespace PR16529 {
struct U {};
template <typename T> struct S {
static decltype(T{}, U{}) &f();
};
U &r = S<int>::f();
}
namespace PR18876 {
struct A { ~A() = delete; }; // expected-note +{{here}}
A f();
decltype(f()) *a; // ok, function call
decltype(A()) *b; // expected-error {{attempt to use a deleted function}}
decltype(0, f()) *c; // ok, function call on RHS of comma
decltype(0, A()) *d; // expected-error {{attempt to use a deleted function}}
decltype(f(), 0) *e; // expected-error {{attempt to use a deleted function}}
}
namespace D5789 {
struct P1 { char x[6]; } g1 = { "foo" };
struct LP1 { struct P1 p1; };
// expected-warning@+3 {{initializer partially overrides}}
// expected-note@+2 {{previous initialization}}
// expected-note@+1 {{previous definition}}
template<class T> void foo(decltype(T(LP1{ .p1 = g1, .p1.x[1] = 'x' }))) {}
// expected-warning@+3 {{initializer partially overrides}}
// expected-note@+2 {{previous initialization}}
template<class T>
void foo(decltype(T(LP1{ .p1 = g1, .p1.x[1] = 'r' }))) {} // okay
// expected-warning@+3 {{initializer partially overrides}}
// expected-note@+2 {{previous initialization}}
template<class T>
void foo(decltype(T(LP1{ .p1 = { "foo" }, .p1.x[1] = 'x'}))) {} // okay
// expected-warning@+3 {{initializer partially overrides}}
// expected-note@+2 {{previous initialization}}
// expected-error@+1 {{redefinition of 'foo'}}
template<class T> void foo(decltype(T(LP1{ .p1 = g1, .p1.x[1] = 'x' }))) {}
}
namespace GH58674 {
struct Foo {
float value_;
struct nested {
float value_;
};
};
template <typename T>
struct TemplateFoo {
float value_;
};
float bar;
template <typename T>
struct Animal{};
template <typename T>
class Cat : Animal<T> {
using okay = decltype(Foo::value_);
using also_okay = decltype(bar);
using okay2 = decltype(Foo::nested::value_);
using okay3 = decltype(TemplateFoo<T>::value_);
public:
void meow() {
using okay = decltype(Foo::value_);
using also_okay = decltype(bar);
using okay2 = decltype(Foo::nested::value_);
using okay3 = decltype(TemplateFoo<T>::value_);
}
};
void baz() {
Cat<void>{}.meow();
}
}
template<typename>
class conditional {
};
// FIXME: The diagnostics here are produced twice.
void foo(conditional<decltype((1),int>) { // expected-note 2 {{to match this '('}} expected-error {{expected ')'}} expected-note 2{{to match this '<'}}
} // expected-error {{expected function body after function declarator}} expected-error 2 {{expected '>'}} expected-error {{expected ')'}}
|
