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 } 142