[ObjC] Diagnose implicit type coercion from ObjC 'Class' to object pointer types.

[jyknight]

Summary

For example, in Objective-C mode, the initialization of 'x' in:

@implementation MyType
+ (void)someClassMethod {
  MyType *x = self;
}
@end

is correctly diagnosed with an incompatible-pointer-types warning, but
in Objective-C++ mode, it is not diagnosed at all -- even though
incompatible pointer conversions generally become an error in C++.

This patch fixes that oversight, allowing implicit conversions
involving Class only to/from unqualified-id, and between qualified and
unqualified Class, where the protocols are compatible.

Note that this does change some behaviors in Objective-C, as well, as
shown by the modified tests.

Of particular note is that assignment from from 'Class<MyProtocol>' to
'id<MyProtocol>' now warns. (Despite appearances, those are not
compatible types. 'Class<MyProtocol>' is not expected to have instance
methods defined by 'MyProtocol', while 'id<MyProtocol>' is.)

[jyknight]

Note that the test-case diffs are on top of https://reviews.llvm.org/D67982, which I split out to make the actual change in behavior in this commit clearer.

[rjmccall]

LGTM.

[thakis]

After this, Class can no longer be used as a key type in an Obj-C dictionary literal. Is that intentional?

[jyknight]

In D67983#1723376, @thakis wrote:

After this, Class can no longer be used as a key type in an Obj-C dictionary literal. Is that intentional?

Such code was already an on by default incompatible-pointer-types warning in ObjC mode. That it worked in ObjC++ was accidental.

For example:

foo.m:

#import <Foundation/Foundation.h>

int main() {
  NSDictionary* d = @{[NSArray class] : @"bar"};
}

Compiling:

$ clang -framework Foundation -o foo foo.m
foo.m:4:23: warning: incompatible pointer types passing 'Class' to parameter of type 'id<NSCopying> _Nonnull' [-Wincompatible-pointer-types]
  NSDictionary* d = @{[NSArray class] : @"bar"};
                      ^~~~~~~~~~~~~~~
1 warning generated.

While the default metaclass does in fact implement the one method NSCopying declares, it's not possible within the language to declare that the Class -- itself, as an instance -- implements the instance methods from the NSCopying protocol.

You can fix the code just by doing @{(id)clz : val}, since id is freely castable to anything.

[thakis]

While the default metaclass does in fact implement the one method NSCopying declares, it's not possible within the language to declare that the Class -- itself, as an instance -- implements the instance methods from the NSCopying protocol.

Should the compiler just know that then?

You can fix the code just by doing @{(id)clz : val}, since id is freely castable to anything.

[rjmccall]

We could probably do a quick check to see if the class informally conforms to the protocol. +copyWithZone seems to be marked unavailable in ARC; not sure if that would cause problems for such a check.

[jyknight]

In D67983#1723681, @rjmccall wrote:

We could probably do a quick check to see if the class informally conforms to the protocol. +copyWithZone seems to be marked unavailable in ARC; not sure if that would cause problems for such a check.

What kind of check did you have in mind? We might hard-code the compiler to think that the "Class" type "implements" NSObject/NSCopying and thus is implicitly convertible to id<NSObject> and id<NSCopying>. That usually would be OK since the default metaclass in the normal runtime in fact does so. However, there's no such guarantee, and that kind of hardcoding seems generally kinda sketchy.

Given that this code was already being diagnosed for a long time in ObjC mode, I'm not sure that adding such a hack is really warranted. I'll add a bit to the release notes, though.

[rjmccall]

I was thinking that we could walk through the instance methods of the protocol and check whether the class has compatible declarations of class methods. But you're right, of course: we don't actually know what class we're working with, and we'd have to look through [NSFoo self] / [NSFoo class] just to cover the common case of a "direct" reference to a class, which would be a novel step in assuming things about standard methods. So the only way we could do this in general would be to just assume that all classes conform to certain special protocols.

[thakis]

Just doing nothing is fine with me.

I'll note that this change required several changes in our Obj-C++ codebase, and we don't have all that much Obj-C++ code in Chromium. Most of the changes made the code better, but I'd imagine that folks with more Obj-C++ code might need some amount of time to adopt their code. (Our changes: https://chromium-review.googlesource.com/c/chromium/src/+/1878075 https://chromium-review.googlesource.com/c/chromium/src/+/1884671 )

[jyknight]

Updated release notes in d11a9018b773c0359934a7989d886b02468112e4.

[arphaman]

@jyknight @rjmccall I'm not sure this change is 100% fine. For example, the following code no longer compiles with ARC:

@protocol Delegate
@end

@interface X <Delegate>

@end

@interface Y
@property id<Delegate> d;
@end

@implementation X

+ (void)foo:(Y *)y with:(X*)x {
 y.d = self; // error: assigning to 'id<Delegate>' from incompatible type 'const Class'
 y.d = x;     // fine
}

@end

[jyknight]

In D67983#1863019, @arphaman wrote:

@jyknight @rjmccall I'm not sure this change is 100% fine. For example, the following code no longer compiles with ARC:

@protocol Delegate
@end

@interface X <Delegate>

@end

@interface Y
@property id<Delegate> d;
@end

@implementation X

+ (void)foo:(Y *)y with:(X*)x {
 y.d = self; // error: assigning to 'id<Delegate>' from incompatible type 'const Class'
 y.d = x;     // fine
}

@end

Your error looks correct to me -- "self" in a classmethod is not an instance, but the class itself. And while instances of X implement "Delegate", the Class does not.

[arphaman]

In D67983#1863981, @jyknight wrote:

In D67983#1863019, @arphaman wrote:

@jyknight @rjmccall I'm not sure this change is 100% fine. For example, the following code no longer compiles with ARC:

@protocol Delegate
@end

@interface X <Delegate>

@end

@interface Y
@property id<Delegate> d;
@end

@implementation X

+ (void)foo:(Y *)y with:(X*)x {
 y.d = self; // error: assigning to 'id<Delegate>' from incompatible type 'const Class'
 y.d = x;     // fine
}

@end

Your error looks correct to me -- "self" in a classmethod is not an instance, but the class itself. And while instances of X implement "Delegate", the Class does not.

Got it, thanks! We might need to add a flag to allow the old behavior temporarily to accommodate our codebase while it's being updated.

[jyknight]

Your error looks correct to me -- "self" in a classmethod is not an instance, but the class itself. And while instances of X implement "Delegate", the Class does not.

Got it, thanks! We might need to add a flag to allow the old behavior temporarily to accommodate our codebase while it's being updated.

Adding an explicit cast would be the simplest way to allow your code to continue being broken in the same way it was previously broken. E.g.

// TODO: fix the types here -- self is _not_ actually an id<Delegate>!
y.d = static_cast<id<Delegate>>(self);

clang/lib/AST/ASTContext.cpp

bool ASTContext::ObjCQualifiedClassTypesAreCompatible(
   return true;
 }
 
 /// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an
 /// ObjCQualifiedIDType.
 bool ASTContext::ObjCQualifiedIdTypesAreCompatible(
     const ObjCObjectPointerType *lhs, const ObjCObjectPointerType *rhs,
     bool compare) {
-  // Allow id<P..> and an 'id' or void* type in all cases.
-  if (lhs->isVoidPointerType() ||
-      lhs->isObjCIdType() || lhs->isObjCClassType())
-    return true;
-  else if (rhs->isVoidPointerType() ||
-           rhs->isObjCIdType() || rhs->isObjCClassType())
+  // Allow id<P..> and an 'id' in all cases.
+  if (lhs->isObjCIdType() || rhs->isObjCIdType())
     return true;
 
+  // Don't allow id<P..> to convert to Class or Class<P..> in either direction.
+  if (lhs->isObjCClassType() || lhs->isObjCQualifiedClassType() ||
+      rhs->isObjCClassType() || rhs->isObjCQualifiedClassType())
+    return false;
+
   if (lhs->isObjCQualifiedIdType()) {
     if (rhs->qual_empty()) {
       // If the RHS is a unqualified interface pointer "NSString*",
       // make sure we check the class hierarchy.
       if (ObjCInterfaceDecl *rhsID = rhs->getInterfaceDecl()) {
         for (auto *I : lhs->quals()) {
           // when comparing an id<P> on lhs with a static type on rhs,
           // see if static class implements all of id's protocols, directly or

 /// canAssignObjCInterfaces - Return true if the two interface types are
 /// compatible for assignment from RHS to LHS.  This handles validation of any
 /// protocol qualifiers on the LHS or RHS.
 bool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
                                          const ObjCObjectPointerType *RHSOPT) {
   const ObjCObjectType* LHS = LHSOPT->getObjectType();
   const ObjCObjectType* RHS = RHSOPT->getObjectType();
 
-  // If either type represents the built-in 'id' or 'Class' types, return true.
-  if (LHS->isObjCUnqualifiedIdOrClass() ||
-      RHS->isObjCUnqualifiedIdOrClass())
+  // If either type represents the built-in 'id' type, return true.
+  if (LHS->isObjCUnqualifiedId() || RHS->isObjCUnqualifiedId())
     return true;
 
   // Function object that propagates a successful result or handles
   // __kindof types.
   auto finish = [&](bool succeeded) -> bool {
     if (succeeded)
       return true;
 
     if (!RHS->isKindOfType())
       return false;
 
     // Strip off __kindof and protocol qualifiers, then check whether
     // we can assign the other way.
     return canAssignObjCInterfaces(RHSOPT->stripObjCKindOfTypeAndQuals(*this),
                                    LHSOPT->stripObjCKindOfTypeAndQuals(*this));
   };
 
+  // Casts from or to id<P> are allowed when the other side has compatible
+  // protocols.
   if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) {
     return finish(ObjCQualifiedIdTypesAreCompatible(LHSOPT, RHSOPT, false));
   }
 
+  // Verify protocol compatibility for casts from Class<P1> to Class<P2>.
   if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) {
     return finish(ObjCQualifiedClassTypesAreCompatible(LHSOPT, RHSOPT));
   }
 
+  // Casts from Class to Class<Foo>, or vice-versa, are allowed.
+  if (LHS->isObjCClass() && RHS->isObjCClass()) {
+    return true;
+  }
+
   // If we have 2 user-defined types, fall into that path.
   if (LHS->getInterface() && RHS->getInterface()) {
     return finish(canAssignObjCInterfaces(LHS, RHS));
   }
 
   return false;
 }
 

clang/lib/Sema/SemaExpr.cpp

static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc,
 
   QualType LHSType = LHS.get()->getType();
   QualType RHSType = RHS.get()->getType();
   assert(LHSType->isPointerType() || RHSType->isPointerType() ||
          LHSType->isMemberPointerType() || RHSType->isMemberPointerType());
 
   QualType T = S.FindCompositePointerType(Loc, LHS, RHS);
   if (T.isNull()) {
-    if ((LHSType->isPointerType() || LHSType->isMemberPointerType()) &&
-        (RHSType->isPointerType() || RHSType->isMemberPointerType()))
+    if ((LHSType->isAnyPointerType() || LHSType->isMemberPointerType()) &&
+        (RHSType->isAnyPointerType() || RHSType->isMemberPointerType()))
       diagnoseDistinctPointerComparison(S, Loc, LHS, RHS, /*isError*/true);
     else
       S.InvalidOperands(Loc, LHS, RHS);
     return true;
   }
 
   LHS = S.ImpCastExprToType(LHS.get(), T, CK_BitCast);
   RHS = S.ImpCastExprToType(RHS.get(), T, CK_BitCast);

clang/test/SemaObjC/comptypes-1.m

int main()
   /* Assigning to an 'id<MyProtocol>' variable should generate a
      warning if done from a 'MyClass *' (which doesn't implement
      MyProtocol), but not from an 'id' or from a 'MyOtherClass *'
      (which implements MyProtocol).  */
   obj_p = obj;    /* Ok */
   obj_p = obj_c;  // expected-warning {{assigning to 'id<MyProtocol>' from incompatible type 'MyClass *'}}
   obj_p = obj_cp; /* Ok  */
   obj_p = obj_C;  // expected-warning {{incompatible pointer types assigning to 'id<MyProtocol>' from 'Class'}}
-  obj_p = obj_CP; // FIXME -- should warn {{assigning to 'id<MyProtocol>' from incompatible type 'Class<MyProtocol>'}}
+  obj_p = obj_CP; // expected-warning {{assigning to 'id<MyProtocol>' from incompatible type 'Class<MyProtocol>'}}
 
   /* Assigning to a 'MyOtherClass *' variable should always generate
      a warning, unless done from an 'id' or an 'id<MyProtocol>' (since
      MyOtherClass implements MyProtocol).  */
   obj_cp = obj;    /* Ok */
   obj_cp = obj_c;  // expected-warning {{incompatible pointer types assigning to 'MyOtherClass *' from 'MyClass *'}}
   obj_cp = obj_p;  /* Ok */
   obj_cp = obj_C;  // expected-warning {{incompatible pointer types assigning to 'MyOtherClass *' from 'Class'}}
int main()
   /* Any comparison between 'MyClass *' and anything which is not an 'id'
      must generate a warning.  */
   if (obj_c == obj_p) foo();  // expected-warning {{comparison of distinct pointer types ('MyClass *' and 'id<MyProtocol>')}}
   if (obj_p == obj_c) foo();  // expected-warning {{comparison of distinct pointer types ('id<MyProtocol>' and 'MyClass *')}}
 
   if (obj_c == obj_cp) foo(); // expected-warning {{comparison of distinct pointer types ('MyClass *' and 'MyOtherClass *')}}
   if (obj_cp == obj_c) foo(); // expected-warning {{comparison of distinct pointer types ('MyOtherClass *' and 'MyClass *')}}
 
-  if (obj_c == obj_C) foo();  // FIXME -- should warn {{comparison of distinct pointer types ('MyClass *' and 'Class')}}
-  if (obj_C == obj_c) foo();  // FIXME -- should warn {{comparison of distinct pointer types ('Class' and 'MyClass *')}}
+  if (obj_c == obj_C) foo();  // expected-warning {{comparison of distinct pointer types ('MyClass *' and 'Class')}}
+  if (obj_C == obj_c) foo();  // expected-warning {{comparison of distinct pointer types ('Class' and 'MyClass *')}}
 
   if (obj_c == obj_CP) foo(); // expected-warning {{comparison of distinct pointer types ('MyClass *' and 'Class<MyProtocol>')}}
   if (obj_CP == obj_c) foo(); // expected-warning {{comparison of distinct pointer types ('Class<MyProtocol>' and 'MyClass *')}}
 
   /* Any comparison between 'MyOtherClass *' (which implements
      MyProtocol) and an 'id' implementing MyProtocol are Ok.  */
   if (obj_p == obj_cp) foo();  /* Ok */
   if (obj_cp == obj_p) foo();  /* Ok */
 
-  if (obj_p == obj_C) foo();   // FIXME -- should warn {{comparison of distinct pointer types ('id<MyProtocol>' and 'Class')}}
-  if (obj_C == obj_p) foo();   // FIXME -- should warn {{comparison of distinct pointer types ('Class' and 'id<MyProtocol>')}}
+  if (obj_p == obj_C) foo();   // expected-warning {{comparison of distinct pointer types ('id<MyProtocol>' and 'Class')}}
+  if (obj_C == obj_p) foo();   // expected-warning {{comparison of distinct pointer types ('Class' and 'id<MyProtocol>')}}
 
-  if (obj_p == obj_CP) foo();  // FIXME -- should warn {{comparison of distinct pointer types ('id<MyProtocol>' and 'Class<MyProtocol>')}}
-  if (obj_CP == obj_p) foo();  // FIXME -- should warn {{comparison of distinct pointer types ('Class<MyProtocol>' and 'id<MyProtocol>')}}
+  if (obj_p == obj_CP) foo();  // expected-warning {{comparison of distinct pointer types ('id<MyProtocol>' and 'Class<MyProtocol>')}}
+  if (obj_CP == obj_p) foo();  // expected-warning {{comparison of distinct pointer types ('Class<MyProtocol>' and 'id<MyProtocol>')}}
 
   /* Comparisons between MyOtherClass * and Class types is a warning */
-  if (obj_cp == obj_C) foo();  // FIXME -- should warn {{comparison of distinct pointer types ('MyOtherClass *' and 'Class')}}
-  if (obj_C == obj_cp) foo();  // FIXME -- should warn {{comparison of distinct pointer types ('Class' and 'MyOtherClass *')}}
+  if (obj_cp == obj_C) foo();  // expected-warning {{comparison of distinct pointer types ('MyOtherClass *' and 'Class')}}
+  if (obj_C == obj_cp) foo();  // expected-warning {{comparison of distinct pointer types ('Class' and 'MyOtherClass *')}}
 
   if (obj_cp == obj_CP) foo(); // expected-warning {{comparison of distinct pointer types ('MyOtherClass *' and 'Class<MyProtocol>')}}
   if (obj_CP == obj_cp) foo(); // expected-warning {{comparison of distinct pointer types ('Class<MyProtocol>' and 'MyOtherClass *')}}
 
   /* Comparisons between a Class and a Class<MyProtocol> are ok */
   if (obj_C == obj_CP) foo(); /* Ok */
   if (obj_CP == obj_C) foo(); /* Ok */
 
   return 0;
 }

clang/test/SemaObjCXX/class-method-self.mm

 // RUN: %clang_cc1 -verify -Wno-objc-root-class %s
-// FIXME: expected-no-diagnostics
+
 @interface XX
 
-- (void)addObserver:(XX*)o; // FIXME -- should note 2{{passing argument to parameter 'o' here}}
+- (void)addObserver:(XX*)o; // expected-note 2{{passing argument to parameter 'o' here}}
 
 @end
 
 @interface YY
 
 + (void)classMethod;
 
 @end
 
 @implementation YY
 
 static XX *obj;
 
 + (void)classMethod {
-  [obj addObserver:self];     // FIXME -- should error {{cannot initialize a parameter of type 'XX *' with an lvalue of type 'Class'}}
+  [obj addObserver:self];     // expected-error {{cannot initialize a parameter of type 'XX *' with an lvalue of type 'Class'}}
   Class whatever;
-  [obj addObserver:whatever]; // FIXME -- should error {{cannot initialize a parameter of type 'XX *' with an lvalue of type 'Class'}}
+  [obj addObserver:whatever]; // expected-error {{cannot initialize a parameter of type 'XX *' with an lvalue of type 'Class'}}
 }
 @end
 

clang/test/SemaObjCXX/comptypes-1.mm

int main()
   obj = obj_C;  /* Ok  */
   obj = obj_CP; /* Ok  */
 
   /* Assigning to a 'MyClass *' variable should always generate a
      warning, unless done from an 'id'.  */
   obj_c = obj;    /* Ok */
   obj_c = obj_p;  // expected-error {{assigning to 'MyClass *' from incompatible type 'id<MyProtocol>'}}
   obj_c = obj_cp; // expected-error {{assigning to 'MyClass *' from incompatible type 'MyOtherClass *'}}
-  obj_c = obj_C;  // FIXME -- should error {{assigning to 'MyClass *' from incompatible type 'Class'}}
+  obj_c = obj_C;  // expected-error {{assigning to 'MyClass *' from incompatible type 'Class'}}
   obj_c = obj_CP; // expected-error {{assigning to 'MyClass *' from incompatible type 'Class<MyProtocol>'}}
 
   /* Assigning to an 'id<MyProtocol>' variable should generate a
      warning if done from a 'MyClass *' (which doesn't implement
      MyProtocol), but not from an 'id' or from a 'MyOtherClass *'
      (which implements MyProtocol).  */
   obj_p = obj;    /* Ok */
   obj_p = obj_c;  // expected-error {{assigning to 'id<MyProtocol>' from incompatible type 'MyClass *'}}
   obj_p = obj_cp; /* Ok  */
-  obj_p = obj_C;  // FIXME -- should error {{assigning to 'id<MyProtocol>' from incompatible type 'Class'}}
-  obj_p = obj_CP; // FIXME -- should error {{assigning to 'id<MyProtocol>' from incompatible type 'Class<MyProtocol>'}}
+  obj_p = obj_C;  // expected-error {{assigning to 'id<MyProtocol>' from incompatible type 'Class'}}
+  obj_p = obj_CP; // expected-error {{assigning to 'id<MyProtocol>' from incompatible type 'Class<MyProtocol>'}}
 
   /* Assigning to a 'MyOtherClass *' variable should always generate
      a warning, unless done from an 'id' or an 'id<MyProtocol>' (since
      MyOtherClass implements MyProtocol).  */
   obj_cp = obj;    /* Ok */
   obj_cp = obj_c;  // expected-error {{assigning to 'MyOtherClass *' from incompatible type 'MyClass *'}}
   obj_cp = obj_p;  /* Ok */
-  obj_cp = obj_C;  // FIXME -- should error {{assigning to 'MyOtherClass *' from incompatible type 'Class'}}
+  obj_cp = obj_C;  // expected-error {{assigning to 'MyOtherClass *' from incompatible type 'Class'}}
   obj_cp = obj_CP; // expected-error {{assigning to 'MyOtherClass *' from incompatible type 'Class<MyProtocol>'}}
 
   obj_C = obj;     // Ok
-  obj_C = obj_p;   // FIXME -- should error {{assigning to 'Class' from incompatible type 'id<MyProtocol>'}}
-  obj_C = obj_c;   // FIXME -- should error {{assigning to 'Class' from incompatible type 'MyClass *'}}
-  obj_C = obj_cp;  // FIXME -- should error {{assigning to 'Class' from incompatible type 'MyOtherClass *'}}
+  obj_C = obj_p;   // expected-error {{assigning to 'Class' from incompatible type 'id<MyProtocol>'}}
+  obj_C = obj_c;   // expected-error {{assigning to 'Class' from incompatible type 'MyClass *'}}
+  obj_C = obj_cp;  // expected-error {{assigning to 'Class' from incompatible type 'MyOtherClass *'}}
   obj_C = obj_CP;  // Ok
 
   obj_CP = obj;     // Ok
-  obj_CP = obj_p;   // expected-warning {{incompatible pointer types assigning to 'Class<MyProtocol>' from 'id<MyProtocol>'}} FIXME -- should error {{assigning to 'Class<MyProtocol>' from incompatible type 'id<MyProtocol>'}}
+  obj_CP = obj_p;   // expected-error {{assigning to 'Class<MyProtocol>' from incompatible type 'id<MyProtocol>'}}
   obj_CP = obj_c;   // expected-error {{assigning to 'Class<MyProtocol>' from incompatible type 'MyClass *}}
   obj_CP = obj_cp;  // expected-error {{assigning to 'Class<MyProtocol>' from incompatible type 'MyOtherClass *'}}
   obj_CP = obj_C;   // Ok
 
   /* Any comparison involving an 'id' must be without warnings.  */
   if (obj == obj_p) foo();  /* Ok  */ /*Bogus warning here in 2.95.4*/
   if (obj_p == obj) foo();  /* Ok  */
   if (obj == obj_c) foo();  /* Ok  */
   if (obj_c == obj) foo();  /* Ok  */
   if (obj == obj_cp) foo(); /* Ok  */
   if (obj_cp == obj) foo(); /* Ok  */
   if (obj == obj_C) foo();  /* Ok  */
   if (obj_C == obj) foo();  /* Ok  */
   if (obj == obj_CP) foo(); /* Ok  */
   if (obj_CP == obj) foo(); /* Ok  */
 
   /* Any comparison between 'MyClass *' and anything which is not an 'id'
      must generate a warning.  */
   if (obj_c == obj_p) foo();  // expected-warning {{comparison of distinct pointer types ('MyClass *' and 'id<MyProtocol>')}}
   if (obj_p == obj_c) foo();  // expected-warning {{comparison of distinct pointer types ('id<MyProtocol>' and 'MyClass *')}}
 
   if (obj_c == obj_cp) foo(); // expected-warning {{comparison of distinct pointer types ('MyClass *' and 'MyOtherClass *')}}
   if (obj_cp == obj_c) foo(); // expected-warning {{comparison of distinct pointer types ('MyOtherClass *' and 'MyClass *')}}
 
-  if (obj_c == obj_C) foo();  // FIXME -- should warn {{comparison of distinct pointer types ('MyClass *' and 'Class')}}
-  if (obj_C == obj_c) foo();  // FIXME -- should warn {{comparison of distinct pointer types ('Class' and 'MyClass *')}}
+  if (obj_c == obj_C) foo();  // expected-warning {{comparison of distinct pointer types ('MyClass *' and 'Class')}}
+  if (obj_C == obj_c) foo();  // expected-warning {{comparison of distinct pointer types ('Class' and 'MyClass *')}}
 
   if (obj_c == obj_CP) foo(); // expected-warning {{comparison of distinct pointer types ('MyClass *' and 'Class<MyProtocol>')}}
   if (obj_CP == obj_c) foo(); // expected-warning {{comparison of distinct pointer types ('Class<MyProtocol>' and 'MyClass *')}}
 
   /* Any comparison between 'MyOtherClass *' (which implements
      MyProtocol) and an 'id' implementing MyProtocol are Ok.  */
   if (obj_p == obj_cp) foo();  /* Ok */
   if (obj_cp == obj_p) foo();  /* Ok */
 
-  if (obj_p == obj_C) foo();   // FIXME -- should warn {{comparison of distinct pointer types ('id<MyProtocol>' and 'Class')}}
-  if (obj_C == obj_p) foo();   // FIXME -- should warn {{comparison of distinct pointer types ('Class' and 'id<MyProtocol>')}}
+  if (obj_p == obj_C) foo();   // expected-warning {{comparison of distinct pointer types ('id<MyProtocol>' and 'Class')}}
+  if (obj_C == obj_p) foo();   // expected-warning {{comparison of distinct pointer types ('Class' and 'id<MyProtocol>')}}
 
-  if (obj_p == obj_CP) foo();  // FIXME -- should warn {{comparison of distinct pointer types ('id<MyProtocol>' and 'Class<MyProtocol>')}}
-  if (obj_CP == obj_p) foo();  // FIXME -- should warn {{comparison of distinct pointer types ('Class<MyProtocol>' and 'id<MyProtocol>')}}
+  if (obj_p == obj_CP) foo();  // expected-warning {{comparison of distinct pointer types ('id<MyProtocol>' and 'Class<MyProtocol>')}}
+  if (obj_CP == obj_p) foo();  // expected-warning {{comparison of distinct pointer types ('Class<MyProtocol>' and 'id<MyProtocol>')}}
 
   /* Comparisons between MyOtherClass * and Class types is a warning */
-  if (obj_cp == obj_C) foo();  // FIXME -- should warn {{comparison of distinct pointer types ('MyOtherClass *' and 'Class')}}
-  if (obj_C == obj_cp) foo();  // FIXME -- should warn {{comparison of distinct pointer types ('Class' and 'MyOtherClass *')}}
+  if (obj_cp == obj_C) foo();  // expected-warning {{comparison of distinct pointer types ('MyOtherClass *' and 'Class')}}
+  if (obj_C == obj_cp) foo();  // expected-warning {{comparison of distinct pointer types ('Class' and 'MyOtherClass *')}}
 
   if (obj_cp == obj_CP) foo(); // expected-warning {{comparison of distinct pointer types ('MyOtherClass *' and 'Class<MyProtocol>')}}
   if (obj_CP == obj_cp) foo(); // expected-warning {{comparison of distinct pointer types ('Class<MyProtocol>' and 'MyOtherClass *')}}
 
   /* Comparisons between a Class and a Class<MyProtocol> are ok */
   if (obj_C == obj_CP) foo(); /* Ok */
   if (obj_CP == obj_C) foo(); /* Ok */
 
   return 0;
 }

clang/test/SemaObjCXX/comptypes-7.mm

int main()
 
   j = obj;   // expected-error {{assigning to 'int *' from incompatible type 'id'}}
   j = obj_p; // expected-error {{assigning to 'int *' from incompatible type 'id<MyProtocol>'}}
   j = obj_c; // expected-error {{assigning to 'int *' from incompatible type 'MyClass *'}}
   j = obj_C; // expected-error {{assigning to 'int *' from incompatible type 'Class'}}
 
   if (obj == i) foo() ; // expected-error {{comparison between pointer and integer ('id' and 'int')}}
   if (i == obj) foo() ; // expected-error {{comparison between pointer and integer ('int' and 'id')}}
-  if (obj == j) foo() ; // expected-error {{invalid operands to binary expression ('id' and 'int *')}}
-  if (j == obj) foo() ; // expected-error {{invalid operands to binary expression ('int *' and 'id')}}
+  if (obj == j) foo() ; // expected-error {{comparison of distinct pointer types ('id' and 'int *')}}
+  if (j == obj) foo() ; // expected-error {{comparison of distinct pointer types ('int *' and 'id')}}
 
   if (obj_c == i) foo() ; // expected-error {{comparison between pointer and integer ('MyClass *' and 'int')}}
   if (i == obj_c) foo() ; // expected-error {{comparison between pointer and integer ('int' and 'MyClass *')}}
-  if (obj_c == j) foo() ; // expected-error {{invalid operands to binary expression ('MyClass *' and 'int *')}}
-  if (j == obj_c) foo() ; // expected-error {{invalid operands to binary expression ('int *' and 'MyClass *')}}
+  if (obj_c == j) foo() ; // expected-error {{comparison of distinct pointer types ('MyClass *' and 'int *')}}
+  if (j == obj_c) foo() ; // expected-error {{comparison of distinct pointer types ('int *' and 'MyClass *')}}
 
   if (obj_p == i) foo() ; // expected-error {{comparison between pointer and integer ('id<MyProtocol>' and 'int')}}
   if (i == obj_p) foo() ; // expected-error {{comparison between pointer and integer ('int' and 'id<MyProtocol>')}}
-  if (obj_p == j) foo() ; // expected-error {{invalid operands to binary expression ('id<MyProtocol>' and 'int *')}}
-  if (j == obj_p) foo() ; // expected-error {{invalid operands to binary expression ('int *' and 'id<MyProtocol>')}}
+  if (obj_p == j) foo() ; // expected-error {{comparison of distinct pointer types ('id<MyProtocol>' and 'int *')}}
+  if (j == obj_p) foo() ; // expected-error {{comparison of distinct pointer types ('int *' and 'id<MyProtocol>')}}
 
   if (obj_C == i) foo() ; // expected-error {{comparison between pointer and integer ('Class' and 'int')}}
   if (i == obj_C) foo() ; // expected-error {{comparison between pointer and integer ('int' and 'Class')}}
-  if (obj_C == j) foo() ; // expected-error {{invalid operands to binary expression ('Class' and 'int *')}}
-  if (j == obj_C) foo() ; // expected-error {{invalid operands to binary expression ('int *' and 'Class')}}
+  if (obj_C == j) foo() ; // expected-error {{comparison of distinct pointer types ('Class' and 'int *')}}
+  if (j == obj_C) foo() ; // expected-error {{comparison of distinct pointer types ('int *' and 'Class')}}
 
   Class bar1 = nil;
   Class <MyProtocol> bar = nil;
   bar = bar1;
   bar1 = bar;
 
   return 0;
 }

clang/test/SemaObjCXX/instancetype.mm

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 #if !__has_feature(objc_instancetype)
 # error Missing 'instancetype' feature macro.
 #endif
 
 @interface Root
-+ (instancetype)alloc; // FIXME -- should note {{explicitly declared 'instancetype'}}
++ (instancetype)alloc; // expected-note {{explicitly declared 'instancetype'}}
 - (instancetype)init; // expected-note{{overridden method is part of the 'init' method family}}
 - (instancetype)self; // expected-note {{explicitly declared 'instancetype'}}
 - (Class)class;
 
 @property (assign) Root *selfProp;
 - (instancetype)selfProp;
 @end
 

 @optional
 - (id)methodInProto1;
 - (Subclass1 *)methodInProto2;
 - (int)otherMethodInProto2; // expected-warning{{protocol method is expected to return an instance of the implementing class, but is declared to return 'int'}}
 @end
 
 @implementation Subclass4
 + (id)alloc {
-  return self; // FIXME -- should error{{cannot initialize return object of type 'Subclass4 *' with an lvalue of type 'Class'}}
+  return self; // expected-error{{cannot initialize return object of type 'Subclass4 *' with an lvalue of type 'Class'}}
 }
 
 - (Subclass3 *)init { return 0; } // don't complain: we lost the related return type
 
 - (Subclass3 *)self { return 0; } // expected-warning{{method is expected to return an instance of its class type 'Subclass4', but is declared to return 'Subclass3 *'}}
 
 - (Subclass4 *)initOther { return 0; }