This predicate is just a generic "issuperclass" predicate, move it to the

ObjCInterfaceType as a method.


git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@49306 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 22 insertions, 20 deletions

diff --git a/include/clang/AST/DeclObjC.h b/include/clang/AST/DeclObjC.h
index a3f54c1462..04bf38b87d 100644
--- a/include/clang/AST/DeclObjC.h
+++ b/include/clang/AST/DeclObjC.h
@@ -315,13 +315,26 @@ public:
   
   ObjCCategoryDecl* getCategoryList() const { return CategoryList; }
   void setCategoryList(ObjCCategoryDecl *category) { 
-         CategoryList = category; 
+    CategoryList = category;
   }
+  
+  /// isSuperClassOf - Return true if this class is the specified class or is a
+  /// super class of the specified interface class.
+  bool isSuperClassOf(const ObjCInterfaceDecl *I) const {
+    // If RHS is derived from LHS it is OK; else it is not OK.
+    while (I != NULL) {
+      if (this == I)
+        return true;
+      I = I->getSuperClass();
+    }
+    return false;
+  }
+  
   ObjCIvarDecl *lookupInstanceVariable(IdentifierInfo *ivarName,
                                        ObjCInterfaceDecl *&clsDeclared);
                                                                            
   // Get the local instance method declared in this interface.
-  ObjCMethodDecl *getInstanceMethod(Selector &Sel) {
+  ObjCMethodDecl *getInstanceMethod(Selector Sel) {
     for (instmeth_iterator I = instmeth_begin(), E = instmeth_end(); 
          I != E; ++I) {
       if ((*I)->getSelector() == Sel)
@@ -330,7 +343,7 @@ public:
     return 0;
   }
   // Get the local class method declared in this interface.
-  ObjCMethodDecl *getClassMethod(Selector &Sel) {
+  ObjCMethodDecl *getClassMethod(Selector Sel) {
     for (classmeth_iterator I = classmeth_begin(), E = classmeth_end(); 
          I != E; ++I) {
       if ((*I)->getSelector() == Sel)
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
index a0bbac7485..6e0bfa1a98 100644
--- a/lib/AST/ASTContext.cpp
+++ b/lib/AST/ASTContext.cpp
@@ -1443,20 +1443,6 @@ bool ASTContext::objcTypesAreCompatible(QualType LHS, QualType RHS) {
   return false;
 }
 
-/// isCompatibleInterfaceAssign - Return true if it is ok to assign a
-/// pointer from the RHS interface to the LHS interface.  This is true if the
-/// RHS is exactly LHS or if it is a subclass of LHS.
-static bool isCompatibleInterfaceAssign(ObjCInterfaceDecl *LHS,
-                                        ObjCInterfaceDecl *RHS) {
-  // If RHS is derived from LHS it is OK; else it is not OK.
-  while (RHS != NULL) {
-    if (RHS == LHS)
-      return true;
-    RHS = RHS->getSuperClass();
-  }
-  return false;
-}
-
 bool ASTContext::QualifiedInterfaceTypesAreCompatible(QualType lhs, 
                                                       QualType rhs) {
   const ObjCQualifiedInterfaceType *lhsQI =
@@ -1465,7 +1451,9 @@ bool ASTContext::QualifiedInterfaceTypesAreCompatible(QualType lhs,
     rhs->getAsObjCQualifiedInterfaceType();
   assert(lhsQI && rhsQI && "QualifiedInterfaceTypesAreCompatible - bad type");
   
-  if (!isCompatibleInterfaceAssign(lhsQI->getDecl(), rhsQI->getDecl()))
+  // Verify that the base decls are compatible, the RHS must be a subclass of
+  // the LHS.
+  if (!lhsQI->getDecl()->isSuperClassOf(rhsQI->getDecl()))
     return false;
   
   // All protocols in lhs must have a presence in rhs.
@@ -1857,8 +1845,9 @@ bool ASTContext::typesAreCompatible(QualType LHS_NC, QualType RHS_NC) {
   case Type::Builtin:
     return builtinTypesAreCompatible(LHS, RHS); 
   case Type::ObjCInterface:
-    return isCompatibleInterfaceAssign(cast<ObjCInterfaceType>(LHS)->getDecl(),
-                                       cast<ObjCInterfaceType>(RHS)->getDecl());
+    // The LHS must be a superclass of the RHS.
+    return cast<ObjCInterfaceType>(LHS)->getDecl()->isSuperClassOf(
+                                   cast<ObjCInterfaceType>(RHS)->getDecl());
   case Type::Vector:
   case Type::OCUVector:
     return vectorTypesAreCompatible(LHS, RHS);