CheckObjCInstMethSignature.cpp revision 6fd4505ad67a186da8cc26fdb493c93fe4937555 
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 "ClangSACheckers.h"
17#include "clang/StaticAnalyzer/Core/Checker.h"
18#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
19#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
20#include "clang/AST/DeclObjC.h"
21#include "clang/AST/Type.h"
22#include "clang/AST/ASTContext.h"
23
24#include "llvm/ADT/DenseMap.h"
25#include "llvm/Support/raw_ostream.h"
26
27using namespace clang;
28using namespace ento;
29
30static bool AreTypesCompatible(QualType Derived, QualType Ancestor,
31                               ASTContext &C) {
32
33  // Right now don't compare the compatibility of pointers.  That involves
34  // looking at subtyping relationships.  FIXME: Future patch.
35  if (Derived->isAnyPointerType() &&  Ancestor->isAnyPointerType())
36    return true;
37
38  return C.typesAreCompatible(Derived, Ancestor);
39}
40
41static void CompareReturnTypes(const ObjCMethodDecl *MethDerived,
42                               const ObjCMethodDecl *MethAncestor,
43                               BugReporter &BR, ASTContext &Ctx,
44                               const ObjCImplementationDecl *ID) {
45
46  QualType ResDerived  = MethDerived->getResultType();
47  QualType ResAncestor = MethAncestor->getResultType();
48
49  if (!AreTypesCompatible(ResDerived, ResAncestor, Ctx)) {
50    std::string sbuf;
51    llvm::raw_string_ostream os(sbuf);
52
53    os << "The Objective-C class '"
54       << *MethDerived->getClassInterface()
55       << "', which is derived from class '"
56       << *MethAncestor->getClassInterface()
57       << "', defines the instance method '"
58       << MethDerived->getSelector().getAsString()
59       << "' whose return type is '"
60       << ResDerived.getAsString()
61       << "'.  A method with the same name (same selector) is also defined in "
62          "class '"
63       << *MethAncestor->getClassInterface()
64       << "' and has a return type of '"
65       << ResAncestor.getAsString()
66       << "'.  These two types are incompatible, and may result in undefined "
67          "behavior for clients of these classes.";
68
69    PathDiagnosticLocation MethDLoc =
70      PathDiagnosticLocation::createBegin(MethDerived,
71                                          BR.getSourceManager());
72
73    BR.EmitBasicReport(MethDerived,
74                       "Incompatible instance method return type",
75                       categories::CoreFoundationObjectiveC,
76                       os.str(), MethDLoc);
77  }
78}
79
80static void CheckObjCInstMethSignature(const ObjCImplementationDecl *ID,
81                                       BugReporter& BR) {
82
83  const ObjCInterfaceDecl *D = ID->getClassInterface();
84  const ObjCInterfaceDecl *C = D->getSuperClass();
85
86  if (!C)
87    return;
88
89  ASTContext &Ctx = BR.getContext();
90
91  // Build a DenseMap of the methods for quick querying.
92  typedef llvm::DenseMap<Selector,ObjCMethodDecl*> MapTy;
93  MapTy IMeths;
94  unsigned NumMethods = 0;
95
96  for (ObjCImplementationDecl::instmeth_iterator I=ID->instmeth_begin(),
97       E=ID->instmeth_end(); I!=E; ++I) {
98
99    ObjCMethodDecl *M = *I;
100    IMeths[M->getSelector()] = M;
101    ++NumMethods;
102  }
103
104  // Now recurse the class hierarchy chain looking for methods with the
105  // same signatures.
106  while (C && NumMethods) {
107    for (ObjCInterfaceDecl::instmeth_iterator I=C->instmeth_begin(),
108         E=C->instmeth_end(); I!=E; ++I) {
109
110      ObjCMethodDecl *M = *I;
111      Selector S = M->getSelector();
112
113      MapTy::iterator MI = IMeths.find(S);
114
115      if (MI == IMeths.end() || MI->second == 0)
116        continue;
117
118      --NumMethods;
119      ObjCMethodDecl *MethDerived = MI->second;
120      MI->second = 0;
121
122      CompareReturnTypes(MethDerived, M, BR, Ctx, ID);
123    }
124
125    C = C->getSuperClass();
126  }
127}
128
129//===----------------------------------------------------------------------===//
130// ObjCMethSigsChecker
131//===----------------------------------------------------------------------===//
132
133namespace {
134class ObjCMethSigsChecker : public Checker<
135                                      check::ASTDecl<ObjCImplementationDecl> > {
136public:
137  void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager& mgr,
138                    BugReporter &BR) const {
139    CheckObjCInstMethSignature(D, BR);
140  }
141};
142}
143
144void ento::registerObjCMethSigsChecker(CheckerManager &mgr) {
145  mgr.registerChecker<ObjCMethSigsChecker>();
146}
147