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
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
struct A { int x; }; // expected-note 2 {{candidate constructor}}
class Base {
public:
virtual void f();
};
class Derived : public Base { };
struct ConvertibleToInt {
operator int() const;
};
struct Constructible {
Constructible(int, float);
};
// ---------------------------------------------------------------------
// C-style casts
// ---------------------------------------------------------------------
template<typename T, typename U>
struct CStyleCast0 {
void f(T t) {
(void)((U)t); // expected-error{{cannot convert 'A' to 'int' without a conversion operator}}
}
};
template struct CStyleCast0<int, float>;
template struct CStyleCast0<A, int>; // expected-note{{instantiation}}
// ---------------------------------------------------------------------
// static_cast
// ---------------------------------------------------------------------
template<typename T, typename U>
struct StaticCast0 {
void f(T t) {
(void)static_cast<U>(t); // expected-error{{no matching conversion for static_cast from 'int' to 'A'}}
}
};
template struct StaticCast0<ConvertibleToInt, bool>;
template struct StaticCast0<int, float>;
template struct StaticCast0<int, A>; // expected-note{{instantiation}}
// ---------------------------------------------------------------------
// dynamic_cast
// ---------------------------------------------------------------------
template<typename T, typename U>
struct DynamicCast0 {
void f(T t) {
(void)dynamic_cast<U>(t); // expected-error{{not a reference or pointer}}
}
};
template struct DynamicCast0<Base*, Derived*>;
template struct DynamicCast0<Base*, A>; // expected-note{{instantiation}}
// ---------------------------------------------------------------------
// reinterpret_cast
// ---------------------------------------------------------------------
template<typename T, typename U>
struct ReinterpretCast0 {
void f(T t) {
(void)reinterpret_cast<U>(t); // expected-error{{qualifiers}}
}
};
template struct ReinterpretCast0<void (*)(int), void (*)(float)>;
template struct ReinterpretCast0<int const *, float *>; // expected-note{{instantiation}}
// ---------------------------------------------------------------------
// const_cast
// ---------------------------------------------------------------------
template<typename T, typename U>
struct ConstCast0 {
void f(T t) {
(void)const_cast<U>(t); // expected-error{{not allowed}}
}
};
template struct ConstCast0<int const * *, int * *>;
template struct ConstCast0<int const *, float *>; // expected-note{{instantiation}}
// ---------------------------------------------------------------------
// C++ functional cast
// ---------------------------------------------------------------------
template<typename T, typename U>
struct FunctionalCast1 {
void f(T t) {
(void)U(t); // expected-error{{cannot convert 'A' to 'int' without a conversion operator}}
}
};
template struct FunctionalCast1<int, float>;
template struct FunctionalCast1<A, int>; // expected-note{{instantiation}}
// Generates temporaries, which we cannot handle yet.
template<int N, long M>
struct FunctionalCast2 {
void f() {
(void)Constructible(N, M);
}
};
template struct FunctionalCast2<1, 3>;
// ---------------------------------------------------------------------
// implicit casting
// ---------------------------------------------------------------------
template<typename T>
struct Derived2 : public Base { };
void test_derived_to_base(Base *&bp, Derived2<int> *dp) {
bp = dp;
}
|
