lib/Checker/CheckObjCInstMethSignature.cpp

   1 //=- CheckObjCInstMethodRetTy.cpp - Check ObjC method signatures -*- C++ -*-==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file defines a CheckObjCInstMethSignature, a flow-insenstive check
  11 //  that determines if an Objective-C class interface incorrectly redefines
  12 //  the method signature in a subclass.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "clang/GR/Checkers/LocalCheckers.h"
  17 #include "clang/GR/BugReporter/PathDiagnostic.h"
  18 #include "clang/GR/BugReporter/BugReporter.h"
  19 #include "clang/AST/DeclObjC.h"
  20 #include "clang/AST/Type.h"
  21 #include "clang/AST/ASTContext.h"
  22
  23 #include "llvm/ADT/DenseMap.h"
  24 #include "llvm/Support/raw_ostream.h"
  25
  26 using namespace clang;
  27
  28 static bool AreTypesCompatible(QualType Derived, QualType Ancestor,
  29                                ASTContext& C) {
  30
  31   // Right now don't compare the compatibility of pointers.  That involves
  32   // looking at subtyping relationships.  FIXME: Future patch.
  33   if (Derived->isAnyPointerType() &&  Ancestor->isAnyPointerType())
  34     return true;
  35
  36   return C.typesAreCompatible(Derived, Ancestor);
  37 }
  38
  39 static void CompareReturnTypes(const ObjCMethodDecl *MethDerived,
  40                                const ObjCMethodDecl *MethAncestor,
  41                                BugReporter &BR, ASTContext &Ctx,
  42                                const ObjCImplementationDecl *ID) {
  43
  44   QualType ResDerived  = MethDerived->getResultType();
  45   QualType ResAncestor = MethAncestor->getResultType();
  46
  47   if (!AreTypesCompatible(ResDerived, ResAncestor, Ctx)) {
  48     std::string sbuf;
  49     llvm::raw_string_ostream os(sbuf);
  50
  51     os << "The Objective-C class '"
  52        << MethDerived->getClassInterface()
  53        << "', which is derived from class '"
  54        << MethAncestor->getClassInterface()
  55        << "', defines the instance method '"
  56        << MethDerived->getSelector().getAsString()
  57        << "' whose return type is '"
  58        << ResDerived.getAsString()
  59        << "'.  A method with the same name (same selector) is also defined in "
  60           "class '"
  61        << MethAncestor->getClassInterface()
  62        << "' and has a return type of '"
  63        << ResAncestor.getAsString()
  64        << "'.  These two types are incompatible, and may result in undefined "
  65           "behavior for clients of these classes.";
  66
  67     BR.EmitBasicReport("Incompatible instance method return type",
  68                        os.str(), MethDerived->getLocStart());
  69   }
  70 }
  71
  72 void clang::CheckObjCInstMethSignature(const ObjCImplementationDecl* ID,
  73                                        BugReporter& BR) {
  74
  75   const ObjCInterfaceDecl* D = ID->getClassInterface();
  76   const ObjCInterfaceDecl* C = D->getSuperClass();
  77
  78   if (!C)
  79     return;
  80
  81   ASTContext& Ctx = BR.getContext();
  82
  83   // Build a DenseMap of the methods for quick querying.
  84   typedef llvm::DenseMap<Selector,ObjCMethodDecl*> MapTy;
  85   MapTy IMeths;
  86   unsigned NumMethods = 0;
  87
  88   for (ObjCImplementationDecl::instmeth_iterator I=ID->instmeth_begin(),
  89        E=ID->instmeth_end(); I!=E; ++I) {
  90
  91     ObjCMethodDecl* M = *I;
  92     IMeths[M->getSelector()] = M;
  93     ++NumMethods;
  94   }
  95
  96   // Now recurse the class hierarchy chain looking for methods with the
  97   // same signatures.
  98   while (C && NumMethods) {
  99     for (ObjCInterfaceDecl::instmeth_iterator I=C->instmeth_begin(),
 100          E=C->instmeth_end(); I!=E; ++I) {
 101
 102       ObjCMethodDecl* M = *I;
 103       Selector S = M->getSelector();
 104
 105       MapTy::iterator MI = IMeths.find(S);
 106
 107       if (MI == IMeths.end() || MI->second == 0)
 108         continue;
 109
 110       --NumMethods;
 111       ObjCMethodDecl* MethDerived = MI->second;
 112       MI->second = 0;
 113
 114       CompareReturnTypes(MethDerived, M, BR, Ctx, ID);
 115     }
 116
 117     C = C->getSuperClass();
 118   }
 119 }