1 //===--- CloneChecker.cpp - Clone detection checker -------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// CloneChecker is a checker that reports clones in the current translation
14 //===----------------------------------------------------------------------===//
16 #include "ClangSACheckers.h"
17 #include "clang/Analysis/CloneDetection.h"
18 #include "clang/Basic/Diagnostic.h"
19 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
20 #include "clang/StaticAnalyzer/Core/Checker.h"
21 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
22 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
23 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
25 using namespace clang;
30 : public Checker<check::ASTCodeBody, check::EndOfTranslationUnit> {
31 mutable CloneDetector Detector;
32 mutable std::unique_ptr<BugType> BT_Exact, BT_Suspicious;
35 void checkASTCodeBody(const Decl *D, AnalysisManager &Mgr,
36 BugReporter &BR) const;
38 void checkEndOfTranslationUnit(const TranslationUnitDecl *TU,
39 AnalysisManager &Mgr, BugReporter &BR) const;
41 /// Reports all clones to the user.
42 void reportClones(BugReporter &BR, AnalysisManager &Mgr,
43 std::vector<CloneDetector::CloneGroup> &CloneGroups) const;
45 /// Reports only suspicious clones to the user along with informaton
46 /// that explain why they are suspicious.
47 void reportSuspiciousClones(
48 BugReporter &BR, AnalysisManager &Mgr,
49 std::vector<CloneDetector::CloneGroup> &CloneGroups) const;
51 } // end anonymous namespace
53 void CloneChecker::checkASTCodeBody(const Decl *D, AnalysisManager &Mgr,
54 BugReporter &BR) const {
55 // Every statement that should be included in the search for clones needs to
56 // be passed to the CloneDetector.
57 Detector.analyzeCodeBody(D);
60 void CloneChecker::checkEndOfTranslationUnit(const TranslationUnitDecl *TU,
62 BugReporter &BR) const {
63 // At this point, every statement in the translation unit has been analyzed by
64 // the CloneDetector. The only thing left to do is to report the found clones.
66 int MinComplexity = Mgr.getAnalyzerOptions().getOptionAsInteger(
67 "MinimumCloneComplexity", 10, this);
68 assert(MinComplexity >= 0);
70 bool ReportSuspiciousClones = Mgr.getAnalyzerOptions().getBooleanOption(
71 "ReportSuspiciousClones", true, this);
73 bool ReportNormalClones = Mgr.getAnalyzerOptions().getBooleanOption(
74 "ReportNormalClones", true, this);
76 // Let the CloneDetector create a list of clones from all the analyzed
77 // statements. We don't filter for matching variable patterns at this point
78 // because reportSuspiciousClones() wants to search them for errors.
79 std::vector<CloneDetector::CloneGroup> AllCloneGroups;
81 Detector.findClones(AllCloneGroups, RecursiveCloneTypeIIConstraint(),
82 MinComplexityConstraint(MinComplexity),
83 MinGroupSizeConstraint(2), OnlyLargestCloneConstraint());
85 if (ReportSuspiciousClones)
86 reportSuspiciousClones(BR, Mgr, AllCloneGroups);
88 // We are done for this translation unit unless we also need to report normal
90 if (!ReportNormalClones)
93 // Now that the suspicious clone detector has checked for pattern errors,
94 // we also filter all clones who don't have matching patterns
95 CloneDetector::constrainClones(AllCloneGroups,
96 MatchingVariablePatternConstraint(),
97 MinGroupSizeConstraint(2));
99 reportClones(BR, Mgr, AllCloneGroups);
102 static PathDiagnosticLocation makeLocation(const StmtSequence &S,
103 AnalysisManager &Mgr) {
104 ASTContext &ACtx = Mgr.getASTContext();
105 return PathDiagnosticLocation::createBegin(
106 S.front(), ACtx.getSourceManager(),
107 Mgr.getAnalysisDeclContext(ACtx.getTranslationUnitDecl()));
110 void CloneChecker::reportClones(
111 BugReporter &BR, AnalysisManager &Mgr,
112 std::vector<CloneDetector::CloneGroup> &CloneGroups) const {
115 BT_Exact.reset(new BugType(this, "Exact code clone", "Code clone"));
117 for (const CloneDetector::CloneGroup &Group : CloneGroups) {
118 // We group the clones by printing the first as a warning and all others
120 auto R = llvm::make_unique<BugReport>(*BT_Exact, "Duplicate code detected",
121 makeLocation(Group.front(), Mgr));
122 R->addRange(Group.front().getSourceRange());
124 for (unsigned i = 1; i < Group.size(); ++i)
125 R->addNote("Similar code here", makeLocation(Group[i], Mgr),
126 Group[i].getSourceRange());
127 BR.emitReport(std::move(R));
131 void CloneChecker::reportSuspiciousClones(
132 BugReporter &BR, AnalysisManager &Mgr,
133 std::vector<CloneDetector::CloneGroup> &CloneGroups) const {
134 std::vector<VariablePattern::SuspiciousClonePair> Pairs;
136 for (const CloneDetector::CloneGroup &Group : CloneGroups) {
137 for (unsigned i = 0; i < Group.size(); ++i) {
138 VariablePattern PatternA(Group[i]);
140 for (unsigned j = i + 1; j < Group.size(); ++j) {
141 VariablePattern PatternB(Group[j]);
143 VariablePattern::SuspiciousClonePair ClonePair;
144 // For now, we only report clones which break the variable pattern just
145 // once because multiple differences in a pattern are an indicator that
146 // those differences are maybe intended (e.g. because it's actually a
147 // different algorithm).
148 // FIXME: In very big clones even multiple variables can be unintended,
149 // so replacing this number with a percentage could better handle such
150 // cases. On the other hand it could increase the false-positive rate
151 // for all clones if the percentage is too high.
152 if (PatternA.countPatternDifferences(PatternB, &ClonePair) == 1) {
153 Pairs.push_back(ClonePair);
162 new BugType(this, "Suspicious code clone", "Code clone"));
164 ASTContext &ACtx = BR.getContext();
165 SourceManager &SM = ACtx.getSourceManager();
166 AnalysisDeclContext *ADC =
167 Mgr.getAnalysisDeclContext(ACtx.getTranslationUnitDecl());
169 for (VariablePattern::SuspiciousClonePair &Pair : Pairs) {
170 // FIXME: We are ignoring the suggestions currently, because they are
171 // only 50% accurate (even if the second suggestion is unavailable),
172 // which may confuse the user.
173 // Think how to perform more accurate suggestions?
175 auto R = llvm::make_unique<BugReport>(
177 "Potential copy-paste error; did you really mean to use '" +
178 Pair.FirstCloneInfo.Variable->getNameAsString() + "' here?",
179 PathDiagnosticLocation::createBegin(Pair.FirstCloneInfo.Mention, SM,
181 R->addRange(Pair.FirstCloneInfo.Mention->getSourceRange());
183 R->addNote("Similar code using '" +
184 Pair.SecondCloneInfo.Variable->getNameAsString() + "' here",
185 PathDiagnosticLocation::createBegin(Pair.SecondCloneInfo.Mention,
187 Pair.SecondCloneInfo.Mention->getSourceRange());
189 BR.emitReport(std::move(R));
193 //===----------------------------------------------------------------------===//
194 // Register CloneChecker
195 //===----------------------------------------------------------------------===//
197 void ento::registerCloneChecker(CheckerManager &Mgr) {
198 Mgr.registerChecker<CloneChecker>();