CheckObjCInstMethSignature.cpp source code [clang_source_code/lib/StaticAnalyzer/Checkers/CheckObjCInstMethSignature.cpp]

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-insenstive 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/AST/ASTContext.h"
17	#include "clang/AST/DeclObjC.h"
18	#include "clang/AST/Type.h"
19	#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
20	#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.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 '"
59	<< ResDerived.getAsString()
60	<< "'. A method with the same name (same selector) is also defined in "
61	"class '"
62	<< *MethAncestor->getClassInterface()
63	<< "' and has a return type of '"
64	<< ResAncestor.getAsString()
65	<< "'. These two types are incompatible, and may result in undefined "
66	"behavior for clients of these classes.";
67
68	PathDiagnosticLocation MethDLoc =
69	PathDiagnosticLocation::createBegin(MethDerived,
70	BR.getSourceManager());
71
72	BR.EmitBasicReport(
73	MethDerived, Checker, "Incompatible instance method return type",
74	categories::CoreFoundationObjectiveC, os.str(), MethDLoc);
75	}
76	}
77
78	static void CheckObjCInstMethSignature(const ObjCImplementationDecl *ID,
79	BugReporter &BR,
80	const CheckerBase *Checker) {
81
82	const ObjCInterfaceDecl *D = ID->getClassInterface();
83	const ObjCInterfaceDecl *C = D->getSuperClass();
84
85	if (!C)
86	return;
87
88	ASTContext &Ctx = BR.getContext();
89
90	// Build a DenseMap of the methods for quick querying.
91	typedef llvm::DenseMap<Selector,ObjCMethodDecl*> MapTy;
92	MapTy IMeths;
93	unsigned NumMethods = 0;
94
95	for (auto *M : ID->instance_methods()) {
96	IMeths[M->getSelector()] = M;
97	++NumMethods;
98	}
99
100	// Now recurse the class hierarchy chain looking for methods with the
101	// same signatures.
102	while (C && NumMethods) {
103	for (const auto *M : C->instance_methods()) {
104	Selector S = M->getSelector();
105
106	MapTy::iterator MI = IMeths.find(S);
107
108	if (MI == IMeths.end() \|\| MI->second == nullptr)
109	continue;
110
111	--NumMethods;
112	ObjCMethodDecl *MethDerived = MI->second;
113	MI->second = nullptr;
114
115	CompareReturnTypes(MethDerived, M, BR, Ctx, ID, Checker);
116	}
117
118	C = C->getSuperClass();
119	}
120	}
121
122	//===----------------------------------------------------------------------===//
123	// ObjCMethSigsChecker
124	//===----------------------------------------------------------------------===//
125
126	namespace {
127	class ObjCMethSigsChecker : public Checker<
128	check::ASTDecl<ObjCImplementationDecl> > {
129	public:
130	void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager& mgr,
131	BugReporter &BR) const {
132	CheckObjCInstMethSignature(D, BR, this);
133	}
134	};
135	}
136
137	void ento::registerObjCMethSigsChecker(CheckerManager &mgr) {
138	mgr.registerChecker<ObjCMethSigsChecker>();
139	}
140
141	bool ento::shouldRegisterObjCMethSigsChecker(const LangOptions &LO) {
142	return true;
143	}
144

Clang Project