1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2 class X {
3 public:
4   operator bool();
5   operator int() const;
6 
7   bool f() {
8     return operator bool();
9   }
10 
11   float g() {
12     return operator float(); // expected-error{{use of undeclared 'operator float'}}
13   }
14 };
15 
16 operator int(); // expected-error{{conversion function must be a non-static member function}}
17 
18 operator int; // expected-error{{'operator int' cannot be the name of a variable or data member}}
19 
20 typedef int func_type(int);
21 typedef int array_type[10];
22 
23 class Y {
24 public:
25   void operator bool(int, ...) const; // expected-error{{conversion function cannot have a return type}} \
26   // expected-error{{conversion function cannot have any parameters}}
27 
28   operator float(...) const;  // expected-error{{conversion function cannot be variadic}}
29 
30 
31   operator func_type(); // expected-error{{conversion function cannot convert to a function type}}
32   operator array_type(); // expected-error{{conversion function cannot convert to an array type}}
33 };
34 
35 
36 typedef int INT;
37 typedef INT* INT_PTR;
38 
39 class Z {
40   operator int(); // expected-note {{previous declaration is here}}
41   operator int**(); // expected-note {{previous declaration is here}}
42 
43   operator INT();  // expected-error{{conversion function cannot be redeclared}}
44   operator INT_PTR*(); // expected-error{{conversion function cannot be redeclared}}
45 };
46 
47 
48 class A { };
49 
50 class B : public A {
51 public:
52   operator A&() const; // expected-warning{{conversion function converting 'class B' to its base class 'class A' will never be used}}
53   operator const void() const; // expected-warning{{conversion function converting 'class B' to 'void const' will never be used}}
54   operator const B(); // expected-warning{{conversion function converting 'class B' to itself will never be used}}
55 };
56 
57 // This used to crash Clang.
58 struct Flip;
59 struct Flop { // expected-note{{candidate function}}
60   Flop();
61   Flop(const Flip&); // expected-note{{candidate function}}
62 };
63 struct Flip {
64   operator Flop() const; // expected-note{{candidate function}}
65 };
66 Flop flop = Flip(); // expected-error {{conversion from 'struct Flip' to 'struct Flop' is ambiguous}}
67 
68 // This tests that we don't add the second conversion declaration to the list of user conversions
69 struct C {
70   operator const char *() const;
71 };
72 
73 C::operator const char*() const { return 0; }
74 
75 void f(const C& c) {
76   const char* v = c;
77 }
78 
79 // Test. Conversion in base class is visible in derived class.
80 class XB {
81 public:
82   operator int(); // expected-note {{candidate function}}
83 };
84 
85 class Yb : public XB {
86 public:
87   operator char(); // expected-note {{candidate function}}
88 };
89 
90 void f(Yb& a) {
91   if (a) { } // expected-error {{conversion from 'class Yb' to 'bool' is ambiguous}}
92   int i = a; // OK. calls XB::operator int();
93   char ch = a;  // OK. calls Yb::operator char();
94 }
95 
96 // Test conversion + copy construction.
97 class AutoPtrRef { };
98 
99 class AutoPtr {
100   // FIXME: Using 'unavailable' since we do not have access control yet.
101   // FIXME: The error message isn't so good.
102   AutoPtr(AutoPtr &) __attribute__((unavailable)); // expected-note{{explicitly marked}}
103 
104 public:
105   AutoPtr();
106   AutoPtr(AutoPtrRef);
107 
108   operator AutoPtrRef();
109 };
110 
111 AutoPtr make_auto_ptr();
112 
113 AutoPtr test_auto_ptr(bool Cond) {
114   AutoPtr p1( make_auto_ptr() );
115 
116   AutoPtr p;
117   if (Cond)
118     return p; // expected-error{{call to deleted constructor}}
119 
120   return AutoPtr();
121 }
122 
123 struct A1 {
124   A1(const char *);
125   ~A1();
126 
127 private:
128   A1(const A1&) __attribute__((unavailable)); // expected-note{{here}}
129 };
130 
131 A1 f() {
132   return "Hello"; // expected-error{{invokes deleted copy constructor}}
133 }
134