1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
//===--- UnnecessaryCopyInitialization.cpp - clang-tidy--------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "UnnecessaryCopyInitialization.h"
#include "../utils/LexerUtils.h"
#include "../utils/Matchers.h"
namespace clang {
namespace tidy {
namespace performance {
using namespace ::clang::ast_matchers;
namespace {
AST_MATCHER(VarDecl, isLocalVarDecl) { return Node.isLocalVarDecl(); }
AST_MATCHER(QualType, isPointerType) { return Node->isPointerType(); }
} // namespace
void UnnecessaryCopyInitialization::registerMatchers(
ast_matchers::MatchFinder *Finder) {
auto ConstReference = referenceType(pointee(qualType(isConstQualified())));
auto ConstOrConstReference =
allOf(anyOf(ConstReference, isConstQualified()),
unless(allOf(isPointerType(), unless(pointerType(pointee(qualType(
isConstQualified())))))));
// Match method call expressions where the this argument is a const
// type or const reference. This returned const reference is highly likely to
// outlive the local const reference of the variable being declared.
// The assumption is that the const reference being returned either points
// to a global static variable or to a member of the called object.
auto ConstRefReturningMethodCallOfConstParam = cxxMemberCallExpr(
callee(cxxMethodDecl(returns(ConstReference))),
on(declRefExpr(to(varDecl(hasType(qualType(ConstOrConstReference)))))));
auto ConstRefReturningFunctionCall =
callExpr(callee(functionDecl(returns(ConstReference))),
unless(callee(cxxMethodDecl())));
Finder->addMatcher(
varDecl(
isLocalVarDecl(), hasType(isConstQualified()),
hasType(matchers::isExpensiveToCopy()),
hasInitializer(cxxConstructExpr(
hasDeclaration(cxxConstructorDecl(isCopyConstructor())),
hasArgument(0, anyOf(ConstRefReturningFunctionCall,
ConstRefReturningMethodCallOfConstParam)))))
.bind("varDecl"),
this);
}
void UnnecessaryCopyInitialization::check(
const ast_matchers::MatchFinder::MatchResult &Result) {
const auto *Var = Result.Nodes.getNodeAs<VarDecl>("varDecl");
SourceLocation AmpLocation = Var->getLocation();
auto Token = lexer_utils::getPreviousNonCommentToken(*Result.Context,
Var->getLocation());
if (!Token.is(tok::unknown)) {
AmpLocation = Token.getLocation().getLocWithOffset(Token.getLength());
}
diag(Var->getLocation(),
"the const qualified variable '%0' is copy-constructed from a "
"const reference; consider making it a const reference")
<< Var->getName() << FixItHint::CreateInsertion(AmpLocation, "&");
}
} // namespace performance
} // namespace tidy
} // namespace clang
|
