[AST] const-ify ObjC inherited class search

[modocache]

Summary

When writing an AST matcher to find inherited Objective-C classes, I
noticed the returned ObjCInterfaceDecl* was mutable. It doesn't seem
like it needs to be mutable, so this patch makes it const.

Patch by Adam Ernst.

[adamjernst]

@beng (hello!!) I've spotted you reviewing some Objective-C clang stuff … can you review, or do you have advice on a qualified reviewer?

[beng]

Thanks! @jyknight might want to take a look (this seems fine to me though).

[jyknight]

I don't really have much to say about this, and the patch is probably fine, but I do note that most of the other accessors on this class also return mutable objects.

[modocache]

I'm not super interested in this patch anymore, someone else feel free to work on this! :)

include/clang/AST/DeclObjC.h

ObjCMethodDecl *lookupInstanceMethod(Selector Sel) const {
     return lookupMethod(Sel, true/*isInstance*/);
   }
 
   /// Lookup a class method for a given selector.
   ObjCMethodDecl *lookupClassMethod(Selector Sel) const {
     return lookupMethod(Sel, false/*isInstance*/);
   }
 
-  ObjCInterfaceDecl *lookupInheritedClass(const IdentifierInfo *ICName);
+  const ObjCInterfaceDecl *
+  lookupInheritedClass(const IdentifierInfo *ICName) const;
 
   /// Lookup a method in the classes implementation hierarchy.
   ObjCMethodDecl *lookupPrivateMethod(const Selector &Sel,
                                       bool Instance=true) const;
 
   ObjCMethodDecl *lookupPrivateClassMethod(const Selector &Sel) {
     return lookupPrivateMethod(Sel, false);
   }

lib/AST/DeclObjC.cpp

while (ClassDecl != nullptr) {
     }
 
     ClassDecl = ClassDecl->getSuperClass();
   }
   return nullptr;
 }
 
 /// lookupInheritedClass - This method returns ObjCInterfaceDecl * of the super
-/// class whose name is passed as argument. If it is not one of the super classes
-/// the it returns NULL.
-ObjCInterfaceDecl *ObjCInterfaceDecl::lookupInheritedClass(
-                                        const IdentifierInfo*ICName) {
+/// class whose name is passed as argument. If it is not one of the super
+/// classes then it returns NULL.
+const ObjCInterfaceDecl *
+ObjCInterfaceDecl::lookupInheritedClass(const IdentifierInfo *ICName) const {
   // FIXME: Should make sure no callers ever do this.
   if (!hasDefinition())
     return nullptr;
 
   if (data().ExternallyCompleted)
     LoadExternalDefinition();
 
-  ObjCInterfaceDecl* ClassDecl = this;
+  auto *ClassDecl = this;
   while (ClassDecl != nullptr) {
     if (ClassDecl->getIdentifier() == ICName)
       return ClassDecl;
     ClassDecl = ClassDecl->getSuperClass();
   }
   return nullptr;
 }
 

lib/Sema/SemaDeclObjC.cpp

static void CheckProtocolMethodDefs(Sema &S,
                                     ObjCContainerDecl *CDecl,
                                     LazyProtocolNameSet &ProtocolsExplictImpl) {
   ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl);
   ObjCInterfaceDecl *IDecl = C ? C->getClassInterface()
                                : dyn_cast<ObjCInterfaceDecl>(CDecl);
   assert (IDecl && "CheckProtocolMethodDefs - IDecl is null");
 
   ObjCInterfaceDecl *Super = IDecl->getSuperClass();
-  ObjCInterfaceDecl *NSIDecl = nullptr;
+  const ObjCInterfaceDecl *NSIDecl = nullptr;
 
   // If this protocol is marked 'objc_protocol_requires_explicit_implementation'
   // then we should check if any class in the super class hierarchy also
   // conforms to this protocol, either directly or via protocol inheritance.
   // If so, we can skip checking this protocol completely because we
   // know that a parent class already satisfies this protocol.
   //
   // Note: we could generalize this logic for all protocols, and merely