This is an archive of the discontinued LLVM Phabricator instance.

Differential D51950

[clangtidy] Remove old copy of ExprMutationAnalyzer
ClosedPublic

Authored by shuaiwang on Sep 11 2018, 2:42 PM.

Details

Reviewers
george.karpenkov
JonasToth
Commits
rGf21e8ebb917b: [clangtidy] Remove old copy of ExprMutationAnalyzer
rL342006: [clangtidy] Remove old copy of ExprMutationAnalyzer
rCTE342006: [clangtidy] Remove old copy of ExprMutationAnalyzer
Summary

This is 2/2 of moving ExprMutationAnalyzer from clangtidy to clang/Analysis.
ExprMutationAnalyzer is moved to clang/Analysis in D51948.
This diff migrates existing usages within clangtidy to point to the new
location and remove the old copy of ExprMutationAnalyzer.

Diff Detail

Event Timeline

shuaiwang created this revision.Sep 11 2018, 2:42 PM
Herald added subscribers: cfe-commits, Szelethus, a.sidorin, mgorny. · View Herald TranscriptSep 11 2018, 2:42 PM
Harbormaster completed remote builds in B22508: Diff 164977.Sep 11 2018, 2:43 PM
george.karpenkov added a comment.Sep 11 2018, 2:44 PM

Looks good to me, but I'm not the code owner.

JonasToth added a comment.Sep 11 2018, 2:49 PM

LGTM (not owner, but alexfh was not involved in the ExprMutAnalyzer so
far, i think he has no concerns with moving that around as it is fairly
new as well)

Am 11.09.2018 um 23:44 schrieb George Karpenkov via Phabricator:

george.karpenkov added a comment.

Looks good to me, but I'm not the code owner.

Repository:

rCTE Clang Tools Extra

https://reviews.llvm.org/D51950

george.karpenkov accepted this revision.Sep 11 2018, 2:51 PM
This revision is now accepted and ready to land.Sep 11 2018, 2:51 PM
Closed by commit rCTE342006: [clangtidy] Remove old copy of ExprMutationAnalyzer (authored by shuaiwang). · Explain WhySep 11 2018, 4:00 PM
This revision was automatically updated to reflect the committed changes.
shuaiwang mentioned this in rCTE342012: [NFC] Fix build breakage due to missing dep caused by D51950.Sep 11 2018, 5:33 PM
shuaiwang mentioned this in rL342012: [NFC] Fix build breakage due to missing dep caused by D51950.
Diffusion mentioned this in rGe699a68c2f05: Merge clang-tools-extra: [NFC] Fix build breakage due to missing dep caused by….Oct 29 2019, 5:08 PM

Revision Contents

PathSize
clang-tidy/
performance/
5 lines
6 lines
utils/
1 line
56 lines
313 lines
unittests/
clang-tidy/
1 line
947 lines

Diff 164991

clang-tidy/performance/ForRangeCopyCheck.cpp

//===--- ForRangeCopyCheck.cpp - clang-tidy--------------------------------===// //===--- ForRangeCopyCheck.cpp - clang-tidy--------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ForRangeCopyCheck.h" #include "ForRangeCopyCheck.h"
#include "../utils/DeclRefExprUtils.h" #include "../utils/DeclRefExprUtils.h"
#include "../utils/ExprMutationAnalyzer.h"
#include "../utils/FixItHintUtils.h" #include "../utils/FixItHintUtils.h"
#include "../utils/TypeTraits.h" #include "../utils/TypeTraits.h"
#include "clang/Analysis/Analyses/ExprMutationAnalyzer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace performance { namespace performance {
ForRangeCopyCheck::ForRangeCopyCheck(StringRef Name, ClangTidyContext *Context) ForRangeCopyCheck::ForRangeCopyCheck(StringRef Name, ClangTidyContext *Context)
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Linesbool ForRangeCopyCheck::handleCopyIsOnlyConstReferenced(
// We omit the case where the loop variable is not used in the loop body. E.g. // We omit the case where the loop variable is not used in the loop body. E.g.
// //
// for (auto _ : benchmark_state) { // for (auto _ : benchmark_state) {
// } // }
// //
// Because the fix (changing to `const auto &`) will introduce an unused // Because the fix (changing to `const auto &`) will introduce an unused
// compiler warning which can't be suppressed. // compiler warning which can't be suppressed.
// Since this case is very rare, it is safe to ignore it. // Since this case is very rare, it is safe to ignore it.
if (!utils::ExprMutationAnalyzer(*ForRange.getBody(), Context) if (!ExprMutationAnalyzer(*ForRange.getBody(), Context).isMutated(&LoopVar) &&
.isMutated(&LoopVar) &&
!utils::decl_ref_expr::allDeclRefExprs(LoopVar, *ForRange.getBody(), !utils::decl_ref_expr::allDeclRefExprs(LoopVar, *ForRange.getBody(),
Context) Context)
.empty()) { .empty()) {
diag(LoopVar.getLocation(), diag(LoopVar.getLocation(),
"loop variable is copied but only used as const reference; consider " "loop variable is copied but only used as const reference; consider "
"making it a const reference") "making it a const reference")
<< utils::fixit::changeVarDeclToConst(LoopVar) << utils::fixit::changeVarDeclToConst(LoopVar)
<< utils::fixit::changeVarDeclToReference(LoopVar, Context); << utils::fixit::changeVarDeclToReference(LoopVar, Context);
return true; return true;
} }
return false; return false;
} }
} // namespace performance } // namespace performance
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/performance/UnnecessaryValueParamCheck.cpp

//===--- UnnecessaryValueParamCheck.cpp - clang-tidy-----------------------===// //===--- UnnecessaryValueParamCheck.cpp - clang-tidy-----------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UnnecessaryValueParamCheck.h" #include "UnnecessaryValueParamCheck.h"
#include "../utils/DeclRefExprUtils.h" #include "../utils/DeclRefExprUtils.h"
#include "../utils/ExprMutationAnalyzer.h"
#include "../utils/FixItHintUtils.h" #include "../utils/FixItHintUtils.h"
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "../utils/TypeTraits.h" #include "../utils/TypeTraits.h"
#include "clang/Analysis/Analyses/ExprMutationAnalyzer.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
void UnnecessaryValueParamCheck::check(const MatchFinder::MatchResult &Result) { void UnnecessaryValueParamCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param"); const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param");
const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("functionDecl"); const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("functionDecl");
// Do not trigger on non-const value parameters when they are mutated either // Do not trigger on non-const value parameters when they are mutated either
// within the function body or within init expression(s) when the function is // within the function body or within init expression(s) when the function is
// a ctor. // a ctor.
if (utils::ExprMutationAnalyzer(*Function->getBody(), *Result.Context) if (ExprMutationAnalyzer(*Function->getBody(), *Result.Context)
.isMutated(Param)) .isMutated(Param))
return; return;
// CXXCtorInitializer might also mutate Param but they're not part of function // CXXCtorInitializer might also mutate Param but they're not part of function
// body, so check them separately here. // body, so check them separately here.
if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(Function)) { if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(Function)) {
for (const auto *Init : Ctor->inits()) { for (const auto *Init : Ctor->inits()) {
if (utils::ExprMutationAnalyzer(*Init->getInit(), *Result.Context) if (ExprMutationAnalyzer(*Init->getInit(), *Result.Context)
.isMutated(Param)) .isMutated(Param))
return; return;
} }
} }
const bool IsConstQualified = const bool IsConstQualified =
Param->getType().getCanonicalType().isConstQualified(); Param->getType().getCanonicalType().isConstQualified();
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

clang-tidy/utils/CMakeLists.txt

set(LLVM_LINK_COMPONENTS support) set(LLVM_LINK_COMPONENTS support)
add_clang_library(clangTidyUtils add_clang_library(clangTidyUtils
ASTUtils.cpp ASTUtils.cpp
DeclRefExprUtils.cpp DeclRefExprUtils.cpp
ExprMutationAnalyzer.cpp
ExprSequence.cpp ExprSequence.cpp
FixItHintUtils.cpp FixItHintUtils.cpp
HeaderFileExtensionsUtils.cpp HeaderFileExtensionsUtils.cpp
HeaderGuard.cpp HeaderGuard.cpp
IncludeInserter.cpp IncludeInserter.cpp
IncludeSorter.cpp IncludeSorter.cpp
LexerUtils.cpp LexerUtils.cpp
NamespaceAliaser.cpp NamespaceAliaser.cpp
Show All 11 Lines

clang-tidy/utils/ExprMutationAnalyzer.h

//===---------- ExprMutationAnalyzer.h - clang-tidy -----------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_EXPRMUTATIONANALYZER_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_EXPRMUTATIONANALYZER_H
#include <type_traits>
#include "clang/AST/AST.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "llvm/ADT/DenseMap.h"
namespace clang {
namespace tidy {
namespace utils {
/// Analyzes whether any mutative operations are applied to an expression within
/// a given statement.
class ExprMutationAnalyzer {
public:
ExprMutationAnalyzer(const Stmt &Stm, ASTContext &Context)
: Stm(Stm), Context(Context) {}
bool isMutated(const Decl *Dec) { return findDeclMutation(Dec) != nullptr; }
bool isMutated(const Expr *Exp) { return findMutation(Exp) != nullptr; }
const Stmt *findMutation(const Expr *Exp);
private:
bool isUnevaluated(const Expr *Exp);
const Stmt *findExprMutation(ArrayRef<ast_matchers::BoundNodes> Matches);
const Stmt *findDeclMutation(ArrayRef<ast_matchers::BoundNodes> Matches);
const Stmt *findDeclMutation(const Decl *Dec);
const Stmt *findDirectMutation(const Expr *Exp);
const Stmt *findMemberMutation(const Expr *Exp);
const Stmt *findArrayElementMutation(const Expr *Exp);
const Stmt *findCastMutation(const Expr *Exp);
const Stmt *findRangeLoopMutation(const Expr *Exp);
const Stmt *findReferenceMutation(const Expr *Exp);
const Stmt &Stm;
ASTContext &Context;
llvm::DenseMap<const Expr *, const Stmt *> Results;
};
} // namespace utils
} // namespace tidy
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_EXPRMUTATIONANALYZER_H

clang-tidy/utils/ExprMutationAnalyzer.cpp

//===---------- ExprMutationAnalyzer.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 "ExprMutationAnalyzer.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/ADT/STLExtras.h"
namespace clang {
namespace tidy {
namespace utils {
using namespace ast_matchers;
namespace {
AST_MATCHER_P(LambdaExpr, hasCaptureInit, const Expr *, E) {
return llvm::is_contained(Node.capture_inits(), E);
}
AST_MATCHER_P(CXXForRangeStmt, hasRangeStmt,
ast_matchers::internal::Matcher<DeclStmt>, InnerMatcher) {
const DeclStmt *const Range = Node.getRangeStmt();
return InnerMatcher.matches(*Range, Finder, Builder);
}
const ast_matchers::internal::VariadicDynCastAllOfMatcher<Stmt, CXXTypeidExpr>
cxxTypeidExpr;
AST_MATCHER(CXXTypeidExpr, isPotentiallyEvaluated) {
return Node.isPotentiallyEvaluated();
}
const ast_matchers::internal::VariadicDynCastAllOfMatcher<Stmt, CXXNoexceptExpr>
cxxNoexceptExpr;
const ast_matchers::internal::VariadicDynCastAllOfMatcher<Stmt,
GenericSelectionExpr>
genericSelectionExpr;
AST_MATCHER_P(GenericSelectionExpr, hasControllingExpr,
ast_matchers::internal::Matcher<Expr>, InnerMatcher) {
return InnerMatcher.matches(*Node.getControllingExpr(), Finder, Builder);
}
const auto nonConstReferenceType = [] {
return hasUnqualifiedDesugaredType(
referenceType(pointee(unless(isConstQualified()))));
};
const auto nonConstPointerType = [] {
return hasUnqualifiedDesugaredType(
pointerType(pointee(unless(isConstQualified()))));
};
const auto isMoveOnly = [] {
return cxxRecordDecl(
hasMethod(cxxConstructorDecl(isMoveConstructor(), unless(isDeleted()))),
hasMethod(cxxMethodDecl(isMoveAssignmentOperator(), unless(isDeleted()))),
unless(anyOf(hasMethod(cxxConstructorDecl(isCopyConstructor(),
unless(isDeleted()))),
hasMethod(cxxMethodDecl(isCopyAssignmentOperator(),
unless(isDeleted()))))));
};
} // namespace
const Stmt *ExprMutationAnalyzer::findMutation(const Expr *Exp) {
const auto Memoized = Results.find(Exp);
if (Memoized != Results.end())
return Memoized->second;
if (isUnevaluated(Exp))
return Results[Exp] = nullptr;
for (const auto &Finder : {&ExprMutationAnalyzer::findDirectMutation,
&ExprMutationAnalyzer::findMemberMutation,
&ExprMutationAnalyzer::findArrayElementMutation,
&ExprMutationAnalyzer::findCastMutation,
&ExprMutationAnalyzer::findRangeLoopMutation,
&ExprMutationAnalyzer::findReferenceMutation}) {
if (const Stmt *S = (this->*Finder)(Exp))
return Results[Exp] = S;
}
return Results[Exp] = nullptr;
}
bool ExprMutationAnalyzer::isUnevaluated(const Expr *Exp) {
return selectFirst<Expr>(
"expr",
match(
findAll(
expr(equalsNode(Exp),
anyOf(
// `Exp` is part of the underlying expression of
// decltype/typeof if it has an ancestor of
// typeLoc.
hasAncestor(typeLoc(unless(
hasAncestor(unaryExprOrTypeTraitExpr())))),
hasAncestor(expr(anyOf(
// `UnaryExprOrTypeTraitExpr` is unevaluated
// unless it's sizeof on VLA.
unaryExprOrTypeTraitExpr(unless(sizeOfExpr(
hasArgumentOfType(variableArrayType())))),
// `CXXTypeidExpr` is unevaluated unless it's
// applied to an expression of glvalue of
// polymorphic class type.
cxxTypeidExpr(
unless(isPotentiallyEvaluated())),
// The controlling expression of
// `GenericSelectionExpr` is unevaluated.
genericSelectionExpr(hasControllingExpr(
hasDescendant(equalsNode(Exp)))),
cxxNoexceptExpr())))))
.bind("expr")),
Stm, Context)) != nullptr;
}
const Stmt *
ExprMutationAnalyzer::findExprMutation(ArrayRef<BoundNodes> Matches) {
for (const auto &Nodes : Matches) {
if (const Stmt *S = findMutation(Nodes.getNodeAs<Expr>("expr")))
return S;
}
return nullptr;
}
const Stmt *
ExprMutationAnalyzer::findDeclMutation(ArrayRef<BoundNodes> Matches) {
for (const auto &DeclNodes : Matches) {
if (const Stmt *S = findDeclMutation(DeclNodes.getNodeAs<Decl>("decl")))
return S;
}
return nullptr;
}
const Stmt *ExprMutationAnalyzer::findDeclMutation(const Decl *Dec) {
const auto Refs = match(
findAll(declRefExpr(to(equalsNode(Dec))).bind("expr")), Stm, Context);
for (const auto &RefNodes : Refs) {
const auto *E = RefNodes.getNodeAs<Expr>("expr");
if (findMutation(E))
return E;
}
return nullptr;
}
const Stmt *ExprMutationAnalyzer::findDirectMutation(const Expr *Exp) {
// LHS of any assignment operators.
const auto AsAssignmentLhs =
binaryOperator(isAssignmentOperator(), hasLHS(equalsNode(Exp)));
// Operand of increment/decrement operators.
const auto AsIncDecOperand =
unaryOperator(anyOf(hasOperatorName("++"), hasOperatorName("--")),
hasUnaryOperand(equalsNode(Exp)));
// Invoking non-const member function.
// A member function is assumed to be non-const when it is unresolved.
const auto NonConstMethod = cxxMethodDecl(unless(isConst()));
const auto AsNonConstThis =
expr(anyOf(cxxMemberCallExpr(callee(NonConstMethod), on(equalsNode(Exp))),
cxxOperatorCallExpr(callee(NonConstMethod),
hasArgument(0, equalsNode(Exp))),
callExpr(callee(expr(anyOf(
unresolvedMemberExpr(hasObjectExpression(equalsNode(Exp))),
cxxDependentScopeMemberExpr(
hasObjectExpression(equalsNode(Exp)))))))));
// Taking address of 'Exp'.
// We're assuming 'Exp' is mutated as soon as its address is taken, though in
// theory we can follow the pointer and see whether it escaped `Stm` or is
// dereferenced and then mutated. This is left for future improvements.
const auto AsAmpersandOperand =
unaryOperator(hasOperatorName("&"),
// A NoOp implicit cast is adding const.
unless(hasParent(implicitCastExpr(hasCastKind(CK_NoOp)))),
hasUnaryOperand(equalsNode(Exp)));
const auto AsPointerFromArrayDecay =
castExpr(hasCastKind(CK_ArrayToPointerDecay),
unless(hasParent(arraySubscriptExpr())), has(equalsNode(Exp)));
// Treat calling `operator->()` of move-only classes as taking address.
// These are typically smart pointers with unique ownership so we treat
// mutation of pointee as mutation of the smart pointer itself.
const auto AsOperatorArrowThis =
cxxOperatorCallExpr(hasOverloadedOperatorName("->"),
callee(cxxMethodDecl(ofClass(isMoveOnly()),
returns(nonConstPointerType()))),
argumentCountIs(1), hasArgument(0, equalsNode(Exp)));
// Used as non-const-ref argument when calling a function.
// An argument is assumed to be non-const-ref when the function is unresolved.
const auto NonConstRefParam = forEachArgumentWithParam(
equalsNode(Exp), parmVarDecl(hasType(nonConstReferenceType())));
const auto AsNonConstRefArg = anyOf(
callExpr(NonConstRefParam), cxxConstructExpr(NonConstRefParam),
callExpr(callee(expr(anyOf(unresolvedLookupExpr(), unresolvedMemberExpr(),
cxxDependentScopeMemberExpr(),
hasType(templateTypeParmType())))),
hasAnyArgument(equalsNode(Exp))),
cxxUnresolvedConstructExpr(hasAnyArgument(equalsNode(Exp))));
// Captured by a lambda by reference.
// If we're initializing a capture with 'Exp' directly then we're initializing
// a reference capture.
// For value captures there will be an ImplicitCastExpr <LValueToRValue>.
const auto AsLambdaRefCaptureInit = lambdaExpr(hasCaptureInit(Exp));
// Returned as non-const-ref.
// If we're returning 'Exp' directly then it's returned as non-const-ref.
// For returning by value there will be an ImplicitCastExpr <LValueToRValue>.
// For returning by const-ref there will be an ImplicitCastExpr <NoOp> (for
// adding const.)
const auto AsNonConstRefReturn = returnStmt(hasReturnValue(equalsNode(Exp)));
const auto Matches =
match(findAll(stmt(anyOf(AsAssignmentLhs, AsIncDecOperand, AsNonConstThis,
AsAmpersandOperand, AsPointerFromArrayDecay,
AsOperatorArrowThis, AsNonConstRefArg,
AsLambdaRefCaptureInit, AsNonConstRefReturn))
.bind("stmt")),
Stm, Context);
return selectFirst<Stmt>("stmt", Matches);
}
const Stmt *ExprMutationAnalyzer::findMemberMutation(const Expr *Exp) {
// Check whether any member of 'Exp' is mutated.
const auto MemberExprs =
match(findAll(expr(anyOf(memberExpr(hasObjectExpression(equalsNode(Exp))),
cxxDependentScopeMemberExpr(
hasObjectExpression(equalsNode(Exp)))))
.bind("expr")),
Stm, Context);
return findExprMutation(MemberExprs);
}
const Stmt *ExprMutationAnalyzer::findArrayElementMutation(const Expr *Exp) {
// Check whether any element of an array is mutated.
const auto SubscriptExprs = match(
findAll(arraySubscriptExpr(hasBase(ignoringImpCasts(equalsNode(Exp))))
.bind("expr")),
Stm, Context);
return findExprMutation(SubscriptExprs);
}
const Stmt *ExprMutationAnalyzer::findCastMutation(const Expr *Exp) {
// If 'Exp' is casted to any non-const reference type, check the castExpr.
const auto Casts =
match(findAll(castExpr(hasSourceExpression(equalsNode(Exp)),
anyOf(explicitCastExpr(hasDestinationType(
nonConstReferenceType())),
implicitCastExpr(hasImplicitDestinationType(
nonConstReferenceType()))))
.bind("expr")),
Stm, Context);
return findExprMutation(Casts);
}
const Stmt *ExprMutationAnalyzer::findRangeLoopMutation(const Expr *Exp) {
// If range for looping over 'Exp' with a non-const reference loop variable,
// check all declRefExpr of the loop variable.
const auto LoopVars =
match(findAll(cxxForRangeStmt(
hasLoopVariable(
varDecl(hasType(nonConstReferenceType())).bind("decl")),
hasRangeInit(equalsNode(Exp)))),
Stm, Context);
return findDeclMutation(LoopVars);
}
const Stmt *ExprMutationAnalyzer::findReferenceMutation(const Expr *Exp) {
// Follow non-const reference returned by `operator*()` of move-only classes.
// These are typically smart pointers with unique ownership so we treat
// mutation of pointee as mutation of the smart pointer itself.
const auto Ref = match(
findAll(cxxOperatorCallExpr(
hasOverloadedOperatorName("*"),
callee(cxxMethodDecl(ofClass(isMoveOnly()),
returns(hasUnqualifiedDesugaredType(
nonConstReferenceType())))),
argumentCountIs(1), hasArgument(0, equalsNode(Exp)))
.bind("expr")),
Stm, Context);
if (const Stmt *S = findExprMutation(Ref))
return S;
// If 'Exp' is bound to a non-const reference, check all declRefExpr to that.
const auto Refs = match(
stmt(forEachDescendant(
varDecl(
hasType(nonConstReferenceType()),
hasInitializer(anyOf(equalsNode(Exp),
conditionalOperator(anyOf(
hasTrueExpression(equalsNode(Exp)),
hasFalseExpression(equalsNode(Exp)))))),
hasParent(declStmt().bind("stmt")),
// Don't follow the reference in range statement, we've handled
// that separately.
unless(hasParent(declStmt(hasParent(
cxxForRangeStmt(hasRangeStmt(equalsBoundNode("stmt"))))))))
.bind("decl"))),
Stm, Context);
return findDeclMutation(Refs);
}
} // namespace utils
} // namespace tidy
} // namespace clang

unittests/clang-tidy/CMakeLists.txt

set(LLVM_LINK_COMPONENTS set(LLVM_LINK_COMPONENTS
support support
) )
get_filename_component(CLANG_LINT_SOURCE_DIR get_filename_component(CLANG_LINT_SOURCE_DIR
${CMAKE_CURRENT_SOURCE_DIR}/../../clang-tidy REALPATH) ${CMAKE_CURRENT_SOURCE_DIR}/../../clang-tidy REALPATH)
include_directories(${CLANG_LINT_SOURCE_DIR}) include_directories(${CLANG_LINT_SOURCE_DIR})
add_extra_unittest(ClangTidyTests add_extra_unittest(ClangTidyTests
ClangTidyDiagnosticConsumerTest.cpp ClangTidyDiagnosticConsumerTest.cpp
ClangTidyOptionsTest.cpp ClangTidyOptionsTest.cpp
ExprMutationAnalyzerTest.cpp
IncludeInserterTest.cpp IncludeInserterTest.cpp
GoogleModuleTest.cpp GoogleModuleTest.cpp
LLVMModuleTest.cpp LLVMModuleTest.cpp
NamespaceAliaserTest.cpp NamespaceAliaserTest.cpp
ObjCModuleTest.cpp ObjCModuleTest.cpp
OverlappingReplacementsTest.cpp OverlappingReplacementsTest.cpp
UsingInserterTest.cpp UsingInserterTest.cpp
ReadabilityModuleTest.cpp) ReadabilityModuleTest.cpp)
Show All 18 Lines

unittests/clang-tidy/ExprMutationAnalyzerTest.cpp

//===---------- ExprMutationAnalyzerTest.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 "../clang-tidy/utils/ExprMutationAnalyzer.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Tooling/Tooling.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <cctype>
namespace clang {
namespace tidy {
namespace test {
using namespace clang::ast_matchers;
using ::testing::ElementsAre;
using ::testing::IsEmpty;
using ::testing::ResultOf;
using ::testing::StartsWith;
using ::testing::Values;
namespace {
using ExprMatcher = internal::Matcher<Expr>;
using StmtMatcher = internal::Matcher<Stmt>;
ExprMatcher declRefTo(StringRef Name) {
return declRefExpr(to(namedDecl(hasName(Name))));
}
StmtMatcher withEnclosingCompound(ExprMatcher Matcher) {
return expr(Matcher, hasAncestor(compoundStmt().bind("stmt"))).bind("expr");
}
bool isMutated(const SmallVectorImpl<BoundNodes> &Results, ASTUnit *AST) {
const auto *const S = selectFirst<Stmt>("stmt", Results);
const auto *const E = selectFirst<Expr>("expr", Results);
return utils::ExprMutationAnalyzer(*S, AST->getASTContext()).isMutated(E);
}
SmallVector<std::string, 1>
mutatedBy(const SmallVectorImpl<BoundNodes> &Results, ASTUnit *AST) {
const auto *const S = selectFirst<Stmt>("stmt", Results);
SmallVector<std::string, 1> Chain;
utils::ExprMutationAnalyzer Analyzer(*S, AST->getASTContext());
for (const auto *E = selectFirst<Expr>("expr", Results); E != nullptr;) {
const Stmt *By = Analyzer.findMutation(E);
std::string buffer;
llvm::raw_string_ostream stream(buffer);
By->printPretty(stream, nullptr, AST->getASTContext().getPrintingPolicy());
Chain.push_back(StringRef(stream.str()).trim().str());
E = dyn_cast<DeclRefExpr>(By);
}
return Chain;
}
std::string removeSpace(std::string s) {
s.erase(std::remove_if(s.begin(), s.end(),
[](char c) { return std::isspace(c); }),
s.end());
return s;
}
} // namespace
TEST(ExprMutationAnalyzerTest, Trivial) {
const auto AST = tooling::buildASTFromCode("void f() { int x; x; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
class AssignmentTest : public ::testing::TestWithParam<std::string> {};
TEST_P(AssignmentTest, AssignmentModifies) {
const std::string ModExpr = "x " + GetParam() + " 10";
const auto AST =
tooling::buildASTFromCode("void f() { int x; " + ModExpr + "; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre(ModExpr));
}
INSTANTIATE_TEST_CASE_P(AllAssignmentOperators, AssignmentTest,
Values("=", "+=", "-=", "*=", "/=", "%=", "&=", "|=",
"^=", "<<=", ">>="), );
class IncDecTest : public ::testing::TestWithParam<std::string> {};
TEST_P(IncDecTest, IncDecModifies) {
const std::string ModExpr = GetParam();
const auto AST =
tooling::buildASTFromCode("void f() { int x; " + ModExpr + "; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre(ModExpr));
}
INSTANTIATE_TEST_CASE_P(AllIncDecOperators, IncDecTest,
Values("++x", "--x", "x++", "x--"), );
TEST(ExprMutationAnalyzerTest, NonConstMemberFunc) {
const auto AST = tooling::buildASTFromCode(
"void f() { struct Foo { void mf(); }; Foo x; x.mf(); }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf()"));
}
TEST(ExprMutationAnalyzerTest, AssumedNonConstMemberFunc) {
auto AST = tooling::buildASTFromCodeWithArgs(
"struct X { template <class T> void mf(); };"
"template <class T> void f() { X x; x.mf<T>(); }",
{"-fno-delayed-template-parsing"});
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf<T>()"));
AST = tooling::buildASTFromCodeWithArgs(
"template <class T> void f() { T x; x.mf(); }",
{"-fno-delayed-template-parsing"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf()"));
AST = tooling::buildASTFromCodeWithArgs(
"template <class T> struct X;"
"template <class T> void f() { X<T> x; x.mf(); }",
{"-fno-delayed-template-parsing"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf()"));
}
TEST(ExprMutationAnalyzerTest, ConstMemberFunc) {
const auto AST = tooling::buildASTFromCode(
"void f() { struct Foo { void mf() const; }; Foo x; x.mf(); }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, NonConstOperator) {
const auto AST = tooling::buildASTFromCode(
"void f() { struct Foo { Foo& operator=(int); }; Foo x; x = 10; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x = 10"));
}
TEST(ExprMutationAnalyzerTest, ConstOperator) {
const auto AST = tooling::buildASTFromCode(
"void f() { struct Foo { int operator()() const; }; Foo x; x(); }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, ByValueArgument) {
auto AST =
tooling::buildASTFromCode("void g(int); void f() { int x; g(x); }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode("void g(int*); void f() { int* x; g(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode("typedef int* IntPtr;"
"void g(IntPtr); void f() { int* x; g(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { struct A {}; A operator+(A, int); A x; x + 1; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { struct A { A(int); }; int x; A y(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { struct A { A(); A(A); }; A x; A y(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, ByConstValueArgument) {
auto AST =
tooling::buildASTFromCode("void g(const int); void f() { int x; g(x); }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void g(int* const); void f() { int* x; g(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST =
tooling::buildASTFromCode("typedef int* const CIntPtr;"
"void g(CIntPtr); void f() { int* x; g(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { struct A {}; A operator+(const A, int); A x; x + 1; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { struct A { A(const int); }; int x; A y(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { struct A { A(); A(const A); }; A x; A y(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, ByNonConstRefArgument) {
auto AST =
tooling::buildASTFromCode("void g(int&); void f() { int x; g(x); }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
AST = tooling::buildASTFromCode("typedef int& IntRef;"
"void g(IntRef); void f() { int x; g(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
AST =
tooling::buildASTFromCode("template <class T> using TRef = T&;"
"void g(TRef<int>); void f() { int x; g(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
AST = tooling::buildASTFromCode(
"template <class T> struct identity { using type = T; };"
"template <class T, class U = T&> void g(typename identity<U>::type);"
"void f() { int x; g<int>(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g<int>(x)"));
AST =
tooling::buildASTFromCode("typedef int* IntPtr;"
"void g(IntPtr&); void f() { int* x; g(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
AST = tooling::buildASTFromCode(
"typedef int* IntPtr; typedef IntPtr& IntPtrRef;"
"void g(IntPtrRef); void f() { int* x; g(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
AST = tooling::buildASTFromCode(
"void f() { struct A {}; A operator+(A&, int); A x; x + 1; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x + 1"));
AST = tooling::buildASTFromCode(
"void f() { struct A { A(int&); }; int x; A y(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
AST = tooling::buildASTFromCode(
"void f() { struct A { A(); A(A&); }; A x; A y(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
}
TEST(ExprMutationAnalyzerTest, ByConstRefArgument) {
auto AST = tooling::buildASTFromCode(
"void g(const int&); void f() { int x; g(x); }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode("typedef const int& CIntRef;"
"void g(CIntRef); void f() { int x; g(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"template <class T> using CTRef = const T&;"
"void g(CTRef<int>); void f() { int x; g(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"template <class T> struct identity { using type = T; };"
"template <class T, class U = const T&>"
"void g(typename identity<U>::type);"
"void f() { int x; g<int>(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { struct A {}; A operator+(const A&, int); A x; x + 1; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { struct A { A(const int&); }; int x; A y(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { struct A { A(); A(const A&); }; A x; A y(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, ByNonConstRRefArgument) {
auto AST = tooling::buildASTFromCode(
"void g(int&&); void f() { int x; g(static_cast<int &&>(x)); }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()),
ElementsAre("g(static_cast<int &&>(x))"));
AST = tooling::buildASTFromCode(
"void f() { struct A {}; A operator+(A&&, int); "
"A x; static_cast<A &&>(x) + 1; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()),
ElementsAre("static_cast<A &&>(x) + 1"));
AST = tooling::buildASTFromCode("void f() { struct A { A(int&&); }; "
"int x; A y(static_cast<int &&>(x)); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()),
ElementsAre("static_cast<int &&>(x)"));
AST = tooling::buildASTFromCode("void f() { struct A { A(); A(A&&); }; "
"A x; A y(static_cast<A &&>(x)); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()),
ElementsAre("static_cast<A &&>(x)"));
}
TEST(ExprMutationAnalyzerTest, ByConstRRefArgument) {
auto AST = tooling::buildASTFromCode(
"void g(const int&&); void f() { int x; g(static_cast<int&&>(x)); }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { struct A {}; A operator+(const A&&, int); "
"A x; static_cast<A&&>(x) + 1; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode("void f() { struct A { A(const int&&); }; "
"int x; A y(static_cast<int&&>(x)); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode("void f() { struct A { A(); A(const A&&); }; "
"A x; A y(static_cast<A&&>(x)); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, Move) {
// Technically almost the same as ByNonConstRRefArgument, just double checking
const auto AST = tooling::buildASTFromCode(
"namespace std {"
"template<class T> struct remove_reference { typedef T type; };"
"template<class T> struct remove_reference<T&> { typedef T type; };"
"template<class T> struct remove_reference<T&&> { typedef T type; };"
"template<class T> typename std::remove_reference<T>::type&& "
"move(T&& t) noexcept; }"
"void f() { struct A {}; A x; std::move(x); }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("std::move(x)"));
}
TEST(ExprMutationAnalyzerTest, Forward) {
// Technically almost the same as ByNonConstRefArgument, just double checking
const auto AST = tooling::buildASTFromCode(
"namespace std {"
"template<class T> struct remove_reference { typedef T type; };"
"template<class T> struct remove_reference<T&> { typedef T type; };"
"template<class T> struct remove_reference<T&&> { typedef T type; };"
"template<class T> T&& "
"forward(typename std::remove_reference<T>::type&) noexcept;"
"template<class T> T&& "
"forward(typename std::remove_reference<T>::type&&) noexcept;"
"void f() { struct A {}; A x; std::forward<A &>(x); }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()),
ElementsAre("std::forward<A &>(x)"));
}
TEST(ExprMutationAnalyzerTest, CallUnresolved) {
auto AST = tooling::buildASTFromCodeWithArgs(
"template <class T> void f() { T x; g(x); }",
{"-fno-delayed-template-parsing"});
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
AST = tooling::buildASTFromCodeWithArgs(
"template <int N> void f() { char x[N]; g(x); }",
{"-fno-delayed-template-parsing"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
AST = tooling::buildASTFromCodeWithArgs(
"template <class T> void f(T t) { int x; g(t, x); }",
{"-fno-delayed-template-parsing"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(t, x)"));
AST = tooling::buildASTFromCodeWithArgs(
"template <class T> void f(T t) { int x; t.mf(x); }",
{"-fno-delayed-template-parsing"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("t.mf(x)"));
AST = tooling::buildASTFromCodeWithArgs(
"template <class T> struct S;"
"template <class T> void f() { S<T> s; int x; s.mf(x); }",
{"-fno-delayed-template-parsing"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("s.mf(x)"));
AST = tooling::buildASTFromCodeWithArgs(
"struct S { template <class T> void mf(); };"
"template <class T> void f(S s) { int x; s.mf<T>(x); }",
{"-fno-delayed-template-parsing"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("s.mf<T>(x)"));
AST = tooling::buildASTFromCodeWithArgs("template <class F>"
"void g(F f) { int x; f(x); } ",
{"-fno-delayed-template-parsing"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("f(x)"));
AST = tooling::buildASTFromCodeWithArgs(
"template <class T> void f() { int x; (void)T(x); }",
{"-fno-delayed-template-parsing"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("T(x)"));
}
TEST(ExprMutationAnalyzerTest, ReturnAsValue) {
auto AST = tooling::buildASTFromCode("int f() { int x; return x; }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode("int* f() { int* x; return x; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode("typedef int* IntPtr;"
"IntPtr f() { int* x; return x; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, ReturnAsNonConstRef) {
const auto AST = tooling::buildASTFromCode("int& f() { int x; return x; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("return x;"));
}
TEST(ExprMutationAnalyzerTest, ReturnAsConstRef) {
const auto AST =
tooling::buildASTFromCode("const int& f() { int x; return x; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, ReturnAsNonConstRRef) {
const auto AST = tooling::buildASTFromCode(
"int&& f() { int x; return static_cast<int &&>(x); }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()),
ElementsAre("return static_cast<int &&>(x);"));
}
TEST(ExprMutationAnalyzerTest, ReturnAsConstRRef) {
const auto AST = tooling::buildASTFromCode(
"const int&& f() { int x; return static_cast<int&&>(x); }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, TakeAddress) {
const auto AST =
tooling::buildASTFromCode("void g(int*); void f() { int x; g(&x); }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("&x"));
}
TEST(ExprMutationAnalyzerTest, ArrayToPointerDecay) {
const auto AST =
tooling::buildASTFromCode("void g(int*); void f() { int x[2]; g(x); }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
}
TEST(ExprMutationAnalyzerTest, TemplateWithArrayToPointerDecay) {
const auto AST = tooling::buildASTFromCodeWithArgs(
"template <typename T> struct S { static constexpr int v = 8; };"
"template <> struct S<int> { static constexpr int v = 4; };"
"void g(char*);"
"template <typename T> void f() { char x[S<T>::v]; g(x); }"
"template <> void f<int>() { char y[S<int>::v]; g(y); }",
{"-fno-delayed-template-parsing"});
const auto ResultsX =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(ResultsX, AST.get()), ElementsAre("g(x)"));
const auto ResultsY =
match(withEnclosingCompound(declRefTo("y")), AST->getASTContext());
EXPECT_THAT(mutatedBy(ResultsY, AST.get()), ElementsAre("y"));
}
TEST(ExprMutationAnalyzerTest, FollowRefModified) {
auto AST = tooling::buildASTFromCode(
"void f() { int x; int& r0 = x; int& r1 = r0; int& r2 = r1; "
"int& r3 = r2; r3 = 10; }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()),
ElementsAre("r0", "r1", "r2", "r3", "r3 = 10"));
AST = tooling::buildASTFromCode(
"typedef int& IntRefX;"
"using IntRefY = int&;"
"void f() { int x; IntRefX r0 = x; IntRefY r1 = r0;"
"decltype((x)) r2 = r1; r2 = 10; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()),
ElementsAre("r0", "r1", "r2", "r2 = 10"));
}
TEST(ExprMutationAnalyzerTest, FollowRefNotModified) {
auto AST = tooling::buildASTFromCode(
"void f() { int x; int& r0 = x; int& r1 = r0; int& r2 = r1; "
"int& r3 = r2; int& r4 = r3; int& r5 = r4;}");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { int x; int& r0 = x; const int& r1 = r0;}");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"typedef const int& CIntRefX;"
"using CIntRefY = const int&;"
"void f() { int x; int& r0 = x; CIntRefX r1 = r0;"
"CIntRefY r2 = r1; decltype((r1)) r3 = r2;}");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, FollowConditionalRefModified) {
const auto AST = tooling::buildASTFromCode(
"void f() { int x, y; bool b; int &r = b ? x : y; r = 10; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("r", "r = 10"));
}
TEST(ExprMutationAnalyzerTest, FollowConditionalRefNotModified) {
const auto AST = tooling::buildASTFromCode(
"void f() { int x, y; bool b; int& r = b ? x : y; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, ArrayElementModified) {
const auto AST =
tooling::buildASTFromCode("void f() { int x[2]; x[0] = 10; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x[0] = 10"));
}
TEST(ExprMutationAnalyzerTest, ArrayElementNotModified) {
const auto AST = tooling::buildASTFromCode("void f() { int x[2]; x[0]; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, NestedMemberModified) {
auto AST = tooling::buildASTFromCode(
"void f() { struct A { int vi; }; struct B { A va; }; "
"struct C { B vb; }; C x; x.vb.va.vi = 10; }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.vb.va.vi = 10"));
AST = tooling::buildASTFromCodeWithArgs(
"template <class T> void f() { T x; x.y.z = 10; }",
{"-fno-delayed-template-parsing"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.y.z = 10"));
AST = tooling::buildASTFromCodeWithArgs(
"template <class T> struct S;"
"template <class T> void f() { S<T> x; x.y.z = 10; }",
{"-fno-delayed-template-parsing"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.y.z = 10"));
}
TEST(ExprMutationAnalyzerTest, NestedMemberNotModified) {
auto AST = tooling::buildASTFromCode(
"void f() { struct A { int vi; }; struct B { A va; }; "
"struct C { B vb; }; C x; x.vb.va.vi; }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCodeWithArgs(
"template <class T> void f() { T x; x.y.z; }",
{"-fno-delayed-template-parsing"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCodeWithArgs(
"template <class T> struct S;"
"template <class T> void f() { S<T> x; x.y.z; }",
{"-fno-delayed-template-parsing"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, CastToValue) {
const auto AST =
tooling::buildASTFromCode("void f() { int x; static_cast<double>(x); }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, CastToRefModified) {
auto AST = tooling::buildASTFromCode(
"void f() { int x; static_cast<int &>(x) = 10; }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()),
ElementsAre("static_cast<int &>(x) = 10"));
AST = tooling::buildASTFromCode(
"typedef int& IntRef;"
"void f() { int x; static_cast<IntRef>(x) = 10; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()),
ElementsAre("static_cast<IntRef>(x) = 10"));
}
TEST(ExprMutationAnalyzerTest, CastToRefNotModified) {
const auto AST =
tooling::buildASTFromCode("void f() { int x; static_cast<int&>(x); }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, CastToConstRef) {
auto AST = tooling::buildASTFromCode(
"void f() { int x; static_cast<const int&>(x); }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST =
tooling::buildASTFromCode("typedef const int& CIntRef;"
"void f() { int x; static_cast<CIntRef>(x); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, LambdaDefaultCaptureByValue) {
const auto AST =
tooling::buildASTFromCode("void f() { int x; [=]() { x = 10; }; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, LambdaExplicitCaptureByValue) {
const auto AST =
tooling::buildASTFromCode("void f() { int x; [x]() { x = 10; }; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, LambdaDefaultCaptureByRef) {
const auto AST =
tooling::buildASTFromCode("void f() { int x; [&]() { x = 10; }; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()),
ElementsAre(ResultOf(removeSpace, "[&](){x=10;}")));
}
TEST(ExprMutationAnalyzerTest, LambdaExplicitCaptureByRef) {
const auto AST =
tooling::buildASTFromCode("void f() { int x; [&x]() { x = 10; }; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()),
ElementsAre(ResultOf(removeSpace, "[&x](){x=10;}")));
}
TEST(ExprMutationAnalyzerTest, RangeForArrayByRefModified) {
auto AST = tooling::buildASTFromCode(
"void f() { int x[2]; for (int& e : x) e = 10; }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));
AST = tooling::buildASTFromCode(
"typedef int& IntRef;"
"void f() { int x[2]; for (IntRef e : x) e = 10; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));
}
TEST(ExprMutationAnalyzerTest, RangeForArrayByRefNotModified) {
const auto AST =
tooling::buildASTFromCode("void f() { int x[2]; for (int& e : x) e; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, RangeForArrayByValue) {
auto AST = tooling::buildASTFromCode(
"void f() { int x[2]; for (int e : x) e = 10; }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { int* x[2]; for (int* e : x) e = nullptr; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"typedef int* IntPtr;"
"void f() { int* x[2]; for (IntPtr e : x) e = nullptr; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, RangeForArrayByConstRef) {
auto AST = tooling::buildASTFromCode(
"void f() { int x[2]; for (const int& e : x) e; }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"typedef const int& CIntRef;"
"void f() { int x[2]; for (CIntRef e : x) e; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, RangeForNonArrayByRefModified) {
const auto AST =
tooling::buildASTFromCode("struct V { int* begin(); int* end(); };"
"void f() { V x; for (int& e : x) e = 10; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));
}
TEST(ExprMutationAnalyzerTest, RangeForNonArrayByRefNotModified) {
const auto AST =
tooling::buildASTFromCode("struct V { int* begin(); int* end(); };"
"void f() { V x; for (int& e : x) e; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, RangeForNonArrayByValue) {
const auto AST = tooling::buildASTFromCode(
"struct V { const int* begin() const; const int* end() const; };"
"void f() { V x; for (int e : x) e; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, RangeForNonArrayByConstRef) {
const auto AST = tooling::buildASTFromCode(
"struct V { const int* begin() const; const int* end() const; };"
"void f() { V x; for (const int& e : x) e; }");
const auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, UnevaluatedExpressions) {
auto AST = tooling::buildASTFromCode(
"void f() { int x, y; decltype(x = 10) z = y; }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { int x, y; __typeof(x = 10) z = y; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { int x, y; __typeof__(x = 10) z = y; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode("void f() { int x; sizeof(x = 10); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode("void f() { int x; alignof(x = 10); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode("void f() { int x; noexcept(x = 10); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCodeWithArgs("namespace std { class type_info; }"
"void f() { int x; typeid(x = 10); }",
{"-frtti"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(
"void f() { int x; _Generic(x = 10, int: 0, default: 1); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
}
TEST(ExprMutationAnalyzerTest, NotUnevaluatedExpressions) {
auto AST = tooling::buildASTFromCode("void f() { int x; sizeof(int[x++]); }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x++"));
AST = tooling::buildASTFromCodeWithArgs(
"namespace std { class type_info; }"
"struct A { virtual ~A(); }; struct B : A {};"
"struct X { A& f(); }; void f() { X x; typeid(x.f()); }",
{"-frtti"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.f()"));
}
TEST(ExprMutationAnalyzerTest, UniquePtr) {
const std::string UniquePtrDef =
"template <class T> struct UniquePtr {"
" UniquePtr();"
" UniquePtr(const UniquePtr&) = delete;"
" UniquePtr(UniquePtr&&);"
" UniquePtr& operator=(const UniquePtr&) = delete;"
" UniquePtr& operator=(UniquePtr&&);"
" T& operator*() const;"
" T* operator->() const;"
"};";
auto AST = tooling::buildASTFromCode(
UniquePtrDef + "void f() { UniquePtr<int> x; *x = 10; }");
auto Results =
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("* x = 10"));
AST = tooling::buildASTFromCode(UniquePtrDef +
"void f() { UniquePtr<int> x; *x; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(UniquePtrDef +
"void f() { UniquePtr<const int> x; *x; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(UniquePtrDef +
"struct S { int v; };"
"void f() { UniquePtr<S> x; x->v; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
AST = tooling::buildASTFromCode(UniquePtrDef +
"struct S { int v; };"
"void f() { UniquePtr<const S> x; x->v; }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCode(UniquePtrDef +
"struct S { void mf(); };"
"void f() { UniquePtr<S> x; x->mf(); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
AST = tooling::buildASTFromCode(
UniquePtrDef + "struct S { void mf() const; };"
"void f() { UniquePtr<const S> x; x->mf(); }");
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_FALSE(isMutated(Results, AST.get()));
AST = tooling::buildASTFromCodeWithArgs(
UniquePtrDef + "template <class T> void f() { UniquePtr<T> x; x->mf(); }",
{"-fno-delayed-template-parsing"});
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x->mf()"));
}
} // namespace test
} // namespace tidy
} // namespace clang
clang-tidy/utils/ExprMutationAnalyzer.cpp