[ObjC++] Conversions from specialized to non-specialized objective-c object type should be preferred over conversions to other object pointers

[arphaman]

Summary

Right now Clang will select incorrect overload when the Objective-C interface type is specialized, e.g.:

void overload(Base *b);
void overload(Derived *d);
void test(Base<Base *> b) {
  overload(b); // This will select (Derived *) overload
}

This patch ensures that the conversion from specialized to non-specialized type that points to the same interface is better than the other objective-c pointer conversions.

[ahatanak]

LGTM

cfe/trunk/lib/Sema/SemaOverload.cpp

if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
       bool FromAssignLeft
         = S.Context.canAssignObjCInterfaces(FromPtr1, FromPtr2);
       bool FromAssignRight
         = S.Context.canAssignObjCInterfaces(FromPtr2, FromPtr1);
       bool ToAssignLeft
         = S.Context.canAssignObjCInterfaces(ToPtr1, ToPtr2);
       bool ToAssignRight
         = S.Context.canAssignObjCInterfaces(ToPtr2, ToPtr1);
-      
       // A conversion to an a non-id object pointer type or qualified 'id' 
       // type is better than a conversion to 'id'.
       if (ToPtr1->isObjCIdType() &&
           (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
         return ImplicitConversionSequence::Worse;
       if (ToPtr2->isObjCIdType() &&
           (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
         return ImplicitConversionSequence::Better;
if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
       // A conversion to a non-Class object pointer type is better than a 
       // conversion to a qualified 'Class' type.
       if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
         return ImplicitConversionSequence::Worse;
       if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
         return ImplicitConversionSequence::Better;
 
       //   -- "conversion of C* to B* is better than conversion of C* to A*,"
-      if (S.Context.hasSameType(FromType1, FromType2) && 
+      if (S.Context.hasSameType(FromType1, FromType2) &&
           !FromPtr1->isObjCIdType() && !FromPtr1->isObjCClassType() &&
-          (ToAssignLeft != ToAssignRight))
+          (ToAssignLeft != ToAssignRight)) {
+        if (FromPtr1->isSpecialized()) {
+          // "conversion of B<A> * to B * is better than conversion of B * to
+          // C *.
+          bool IsFirstSame =
+              FromPtr1->getInterfaceDecl() == ToPtr1->getInterfaceDecl();
+          bool IsSecondSame =
+              FromPtr1->getInterfaceDecl() == ToPtr2->getInterfaceDecl();
+          if (IsFirstSame) {
+            if (!IsSecondSame)
+              return ImplicitConversionSequence::Better;
+          } else if (IsSecondSame)
+            return ImplicitConversionSequence::Worse;
+        }
         return ToAssignLeft? ImplicitConversionSequence::Worse
                            : ImplicitConversionSequence::Better;
+      }
 
       //   -- "conversion of B* to A* is better than conversion of C* to A*,"
       if (S.Context.hasSameUnqualifiedType(ToType1, ToType2) &&
           (FromAssignLeft != FromAssignRight))
         return FromAssignLeft? ImplicitConversionSequence::Better
         : ImplicitConversionSequence::Worse;
     }
   }

cfe/trunk/test/SemaObjCXX/overload.mm

namespace rdar9327203 {
   }
 }
 
 namespace class_id {
   // it's okay to overload Class with id.
   void f(Class) { }
   void f(id) { }
 }
+
+@interface NSDictionary<__covariant KeyType, __covariant ObjectType> : A
+@end
+
+@interface NSMutableDictionary<KeyType, ObjectType> : NSDictionary<KeyType, ObjectType>
+@end
+
+namespace rdar20124827 {
+
+int overload(NSDictionary *) { return 1; }
+
+__attribute__((deprecated))  // expected-note {{'overload' has been explicitly marked deprecated here}}
+int overload(NSMutableDictionary *) { return 0; }
+
+__attribute__((deprecated))
+void overload2(NSDictionary *); // expected-note {{candidate function}}
+void overload2(NSDictionary<A *, A *> *); // expected-note {{candidate function}}
+
+void test(NSDictionary *d1, NSDictionary<A *, A *> *d2, NSMutableDictionary<A *, A *> *m1) {
+  overload(d1);
+  overload(d2); // no warning
+  overload(m1); // expected-warning {{'overload' is deprecated}}
+  overload2(d2); // no warning
+  overload2(m1); // expected-error {{call to 'overload2' is ambiguous}}
+}
+
+}