blob: bca75c0b2fb5acf355793a99d40929eb28aaefdd (
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
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
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
class X {
public:
operator bool();
operator int() const;
bool f() {
return operator bool();
}
float g() {
return operator float(); // expected-error{{use of undeclared 'operator float'}}
}
};
operator int(); // expected-error{{conversion function must be a non-static member function}}
operator int; // expected-error{{'operator int' cannot be the name of a variable or data member}}
typedef int func_type(int);
typedef int array_type[10];
class Y {
public:
void operator bool(int, ...) const; // expected-error{{conversion function cannot have a return type}} \
// expected-error{{conversion function cannot have any parameters}}
operator float(...) const; // expected-error{{conversion function cannot be variadic}}
operator func_type(); // expected-error{{conversion function cannot convert to a function type}}
operator array_type(); // expected-error{{conversion function cannot convert to an array type}}
};
typedef int INT;
typedef INT* INT_PTR;
class Z {
operator int(); // expected-note {{previous declaration is here}}
operator int**(); // expected-note {{previous declaration is here}}
operator INT(); // expected-error{{conversion function cannot be redeclared}}
operator INT_PTR*(); // expected-error{{conversion function cannot be redeclared}}
};
class A { };
class B : public A {
public:
operator A&() const; // expected-warning{{conversion function converting 'B' to its base class 'A' will never be used}}
operator const void() const; // expected-warning{{conversion function converting 'B' to 'void const' will never be used}}
operator const B(); // expected-warning{{conversion function converting 'B' to itself will never be used}}
};
// This used to crash Clang.
struct Flip;
struct Flop { // expected-note{{candidate is the implicit copy constructor}}
Flop();
Flop(const Flip&); // expected-note{{candidate constructor}}
};
struct Flip {
operator Flop() const; // expected-note{{candidate function}}
};
Flop flop = Flip(); // expected-error {{conversion from 'Flip' to 'Flop' is ambiguous}}
// This tests that we don't add the second conversion declaration to the list of user conversions
struct C {
operator const char *() const;
};
C::operator const char*() const { return 0; }
void f(const C& c) {
const char* v = c;
}
// Test. Conversion in base class is visible in derived class.
class XB {
public:
operator int(); // expected-note {{candidate function}}
};
class Yb : public XB {
public:
operator char(); // expected-note {{candidate function}}
};
void f(Yb& a) {
if (a) { } // expected-error {{conversion from 'Yb' to 'bool' is ambiguous}}
int i = a; // OK. calls XB::operator int();
char ch = a; // OK. calls Yb::operator char();
}
// Test conversion + copy construction.
class AutoPtrRef { };
class AutoPtr {
// FIXME: Using 'unavailable' since we do not have access control yet.
// FIXME: The error message isn't so good.
AutoPtr(AutoPtr &) __attribute__((unavailable)); // expected-note{{explicitly marked}}
public:
AutoPtr();
AutoPtr(AutoPtrRef);
operator AutoPtrRef();
};
AutoPtr make_auto_ptr();
AutoPtr test_auto_ptr(bool Cond) {
AutoPtr p1( make_auto_ptr() );
AutoPtr p;
if (Cond)
return p; // expected-error{{call to deleted constructor}}
return AutoPtr();
}
struct A1 {
A1(const char *);
~A1();
private:
A1(const A1&) __attribute__((unavailable)); // expected-note{{here}}
};
A1 f() {
return "Hello"; // expected-error{{invokes deleted copy constructor}}
}
|
