| 1 |
//===-- CheckObjCInstMethSignature.cpp - Check ObjC method signatures -----===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
// |
| 9 |
// This file defines a CheckObjCInstMethSignature, a flow-insensitive check |
| 10 |
// that determines if an Objective-C class interface incorrectly redefines |
| 11 |
// the method signature in a subclass. |
| 12 |
// |
| 13 |
//===----------------------------------------------------------------------===// |
| 14 |
|
| 15 |
#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h" |
| 16 |
#include "clang/Analysis/PathDiagnostic.h" |
| 17 |
#include "clang/AST/ASTContext.h" |
| 18 |
#include "clang/AST/DeclObjC.h" |
| 19 |
#include "clang/AST/Type.h" |
| 20 |
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h" |
| 21 |
#include "clang/StaticAnalyzer/Core/Checker.h" |
| 22 |
#include "llvm/ADT/DenseMap.h" |
| 23 |
#include "llvm/Support/raw_ostream.h" |
| 24 |
|
| 25 |
using namespace clang; |
| 26 |
using namespace ento; |
| 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 |
const CheckerBase *Checker) { |
| 44 |
|
| 45 |
QualType ResDerived = MethDerived->getReturnType(); |
| 46 |
QualType ResAncestor = MethAncestor->getReturnType(); |
| 47 |
|
| 48 |
if (!AreTypesCompatible(ResDerived, ResAncestor, Ctx)) { |
| 49 |
std::string sbuf; |
| 50 |
llvm::raw_string_ostream os(sbuf); |
| 51 |
|
| 52 |
os << "The Objective-C class '" |
| 53 |
<< *MethDerived->getClassInterface() |
| 54 |
<< "', which is derived from class '" |
| 55 |
<< *MethAncestor->getClassInterface() |
| 56 |
<< "', defines the instance method '"; |
| 57 |
MethDerived->getSelector().print(os); |
| 58 |
os << "' whose return type is '" << ResDerived |
| 59 |
<< "'. A method with the same name (same selector) is also defined in " |
| 60 |
"class '" |
| 61 |
<< *MethAncestor->getClassInterface() << "' and has a return type of '" |
| 62 |
<< ResAncestor |
| 63 |
<< "'. These two types are incompatible, and may result in undefined " |
| 64 |
"behavior for clients of these classes."; |
| 65 |
|
| 66 |
PathDiagnosticLocation MethDLoc = |
| 67 |
PathDiagnosticLocation::createBegin(MethDerived, |
| 68 |
BR.getSourceManager()); |
| 69 |
|
| 70 |
BR.EmitBasicReport( |
| 71 |
MethDerived, Checker, "Incompatible instance method return type", |
| 72 |
categories::CoreFoundationObjectiveC, os.str(), MethDLoc); |
| 73 |
} |
| 74 |
} |
| 75 |
|
| 76 |
static void CheckObjCInstMethSignature(const ObjCImplementationDecl *ID, |
| 77 |
BugReporter &BR, |
| 78 |
const CheckerBase *Checker) { |
| 79 |
|
| 80 |
const ObjCInterfaceDecl *D = ID->getClassInterface(); |
| 81 |
const ObjCInterfaceDecl *C = D->getSuperClass(); |
| 82 |
|
| 83 |
if (!C) |
| 84 |
return; |
| 85 |
|
| 86 |
ASTContext &Ctx = BR.getContext(); |
| 87 |
|
| 88 |
// Build a DenseMap of the methods for quick querying. |
| 89 |
typedef llvm::DenseMap<Selector,ObjCMethodDecl*> MapTy; |
| 90 |
MapTy IMeths; |
| 91 |
unsigned NumMethods = 0; |
| 92 |
|
| 93 |
for (auto *M : ID->instance_methods()) { |
| 94 |
IMeths[M->getSelector()] = M; |
| 95 |
++NumMethods; |
| 96 |
} |
| 97 |
|
| 98 |
// Now recurse the class hierarchy chain looking for methods with the |
| 99 |
// same signatures. |
| 100 |
while (C && NumMethods) { |
| 101 |
for (const auto *M : C->instance_methods()) { |
| 102 |
Selector S = M->getSelector(); |
| 103 |
|
| 104 |
MapTy::iterator MI = IMeths.find(S); |
| 105 |
|
| 106 |
if (MI == IMeths.end() || MI->second == nullptr) |
| 107 |
continue; |
| 108 |
|
| 109 |
--NumMethods; |
| 110 |
ObjCMethodDecl *MethDerived = MI->second; |
| 111 |
MI->second = nullptr; |
| 112 |
|
| 113 |
CompareReturnTypes(MethDerived, M, BR, Ctx, ID, Checker); |
| 114 |
} |
| 115 |
|
| 116 |
C = C->getSuperClass(); |
| 117 |
} |
| 118 |
} |
| 119 |
|
| 120 |
//===----------------------------------------------------------------------===// |
| 121 |
// ObjCMethSigsChecker |
| 122 |
//===----------------------------------------------------------------------===// |
| 123 |
|
| 124 |
namespace { |
| 125 |
class ObjCMethSigsChecker : public Checker< |
| 126 |
check::ASTDecl<ObjCImplementationDecl> > { |
| 127 |
public: |
| 128 |
void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager& mgr, |
| 129 |
BugReporter &BR) const { |
| 130 |
CheckObjCInstMethSignature(D, BR, this); |
| 131 |
} |
| 132 |
}; |
| 133 |
} |
| 134 |
|
| 135 |
void ento::registerObjCMethSigsChecker(CheckerManager &mgr) { |
| 136 |
mgr.registerChecker<ObjCMethSigsChecker>(); |
| 137 |
} |
| 138 |
|
| 139 |
bool ento::shouldRegisterObjCMethSigsChecker(const CheckerManager &mgr) { |
| 140 |
return true; |
| 141 |
} |