1 files changed, 67 insertions, 20 deletions

diff --git a/test/SemaObjCXX/overload.mm b/test/SemaObjCXX/overload.mm
index 487a42e..7e79a42 100644
--- a/test/SemaObjCXX/overload.mm
+++ b/test/SemaObjCXX/overload.mm
@@ -1,5 +1,4 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
-// XFAIL: *
 @interface Foo
 @end
 
@@ -28,55 +27,65 @@ void func(id);
 @interface C <P1>
 @end
 
-int& f(A*);
-float& f(B*);
+int& f(A*); // expected-note {{candidate}}
+float& f(B*); // expected-note {{candidate}}
 void g(A*);
 
 int& h(A*);
 float& h(id);
 
-void test(A* a, B* b, id val) {
+void test0(A* a, B* b, id val) {
   int& i1 = f(a);
   float& f1 = f(b);
-  float& f2 = f(val);
+
+  // GCC succeeds here, which is clearly ridiculous.
+  float& f2 = f(val); // expected-error {{ambiguous}}
+
   g(a);
   g(b);
   g(val);
   int& i2 = h(a);
   float& f3 = h(val);
-  //  int& i3 = h(b); FIXME: we match GCC here, but shouldn't this work?
+
+  int& i3 = h(b);
 }
 
-void downcast_test(A* a, A** ap) {
-  B* b = a; // expected-warning{{incompatible pointer types initializing 'B *', expected 'A *'}}
-  b = a;  // expected-warning{{incompatible pointer types assigning 'B *', expected 'A *'}}
+void test1(A* a) {
+  B* b = a; // expected-warning{{incompatible pointer types initializing 'A *' with an expression of type 'B *'}}
+  B *c; c = a; // expected-warning{{incompatible pointer types assigning to 'A *' from 'B *'}}
+}
 
-  B** bp = ap; // expected-warning{{incompatible pointer types initializing 'B **', expected 'A **'}}
-  bp = ap; // expected-warning{{incompatible pointer types assigning 'B **', expected 'A **'}}
+void test2(A** ap) {
+  B** bp = ap; // expected-warning{{incompatible pointer types initializing 'A **' with an expression of type 'B **'}}
+  bp = ap; // expected-warning{{incompatible pointer types assigning to 'A **' from 'B **'}}
 }
 
-int& cv(A*);
-float& cv(const A*);
+// FIXME: we should either allow overloading here or give a better diagnostic
+int& cv(A*); // expected-note {{previous declaration}} expected-note 2 {{not viable}}
+float& cv(const A*); // expected-error {{cannot be overloaded}}
+
 int& cv2(void*);
 float& cv2(const void*);
 
 void cv_test(A* a, B* b, const A* ac, const B* bc) {
   int &i1 = cv(a);
   int &i2 = cv(b);
-  float &f1 = cv(ac);
-  float &f2 = cv(bc);
+  float &f1 = cv(ac); // expected-error {{no matching function}}
+  float &f2 = cv(bc); // expected-error {{no matching function}}
   int& i3 = cv2(a);
   float& f3 = cv2(ac);
 }
 
-
-int& qualid(id<P0>);
-float& qualid(id<P1>); // FIXME: GCC complains that this isn't an overload. Is it?
+// We agree with GCC that these can't be overloaded.
+int& qualid(id<P0>); // expected-note {{previous declaration}} expected-note {{not viable}}
+float& qualid(id<P1>); // expected-error {{cannot be overloaded}}
 
 void qualid_test(A *a, B *b, C *c) {
   int& i1 = qualid(a);
   int& i2 = qualid(b);
-  float& f1 = qualid(c);
+
+  // This doesn't work only because the overload was rejected above.
+  float& f1 = qualid(c); // expected-error {{no matching function}}
 
   id<P0> p1 = 0;
   p1 = 0;
@@ -91,7 +100,7 @@ objc_exception_functions_t;
 
 void (*_NSExceptionRaiser(void))(NSException *) {
     objc_exception_functions_t exc_funcs;
-    return exc_funcs.throw_exc; // expected-warning{{incompatible pointer types returning 'void (*)(NSException *)', expected 'void (*)(id)'}}
+    return exc_funcs.throw_exc; // expected-warning{{incompatible pointer types returning 'void (*)(id)' from a function with result type 'void (*)(NSException *)'}}
 }
 
 namespace test5 {
@@ -102,3 +111,41 @@ namespace test5 {
     foo(p);
   }
 }
+
+// rdar://problem/8592139
+namespace test6 {
+  void foo(id); // expected-note{{candidate function}}
+  void foo(A*) __attribute__((unavailable)); // expected-note {{explicitly made unavailable}}
+
+  void test(B *b) {
+    foo(b); // expected-error {{call to unavailable function 'foo'}}
+  }
+}
+
+namespace rdar8714395 {
+  int &f(const void*);
+  float &f(const Foo*);
+
+  int &f2(const void*);
+  float &f2(Foo const* const *);
+
+  int &f3(const void*);
+  float &f3(Foo const**);
+
+  void g(Foo *p) {
+    float &fr = f(p);
+    float &fr2 = f2(&p);
+    int &ir = f3(&p);
+  }
+
+  
+}
+
+namespace rdar8734046 {
+  void f1(id);
+  void f2(id<P0>);
+  void g(const A *a) {
+    f1(a);
+    f2(a);
+  }
+}