diff --git a/clang-tools-extra/clang-tidy/performance/ForRangeCopyCheck.cpp b/clang-tools-extra/clang-tidy/performance/ForRangeCopyCheck.cpp index 0a3cc4f6b42f..d60a2f349f60 100644 --- a/clang-tools-extra/clang-tidy/performance/ForRangeCopyCheck.cpp +++ b/clang-tools-extra/clang-tidy/performance/ForRangeCopyCheck.cpp @@ -9,9 +9,9 @@ #include "ForRangeCopyCheck.h" #include "../utils/DeclRefExprUtils.h" -#include "../utils/ExprMutationAnalyzer.h" #include "../utils/FixItHintUtils.h" #include "../utils/TypeTraits.h" +#include "clang/Analysis/Analyses/ExprMutationAnalyzer.h" using namespace clang::ast_matchers; @@ -88,8 +88,7 @@ bool ForRangeCopyCheck::handleCopyIsOnlyConstReferenced( // Because the fix (changing to `const auto &`) will introduce an unused // compiler warning which can't be suppressed. // Since this case is very rare, it is safe to ignore it. - if (!utils::ExprMutationAnalyzer(*ForRange.getBody(), Context) - .isMutated(&LoopVar) && + if (!ExprMutationAnalyzer(*ForRange.getBody(), Context).isMutated(&LoopVar) && !utils::decl_ref_expr::allDeclRefExprs(LoopVar, *ForRange.getBody(), Context) .empty()) { diff --git a/clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp b/clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp index 63b853dec044..29a8b84cc1e6 100644 --- a/clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp +++ b/clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp @@ -10,10 +10,10 @@ #include "UnnecessaryValueParamCheck.h" #include "../utils/DeclRefExprUtils.h" -#include "../utils/ExprMutationAnalyzer.h" #include "../utils/FixItHintUtils.h" #include "../utils/Matchers.h" #include "../utils/TypeTraits.h" +#include "clang/Analysis/Analyses/ExprMutationAnalyzer.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Lex/Lexer.h" #include "clang/Lex/Preprocessor.h" @@ -95,14 +95,14 @@ void UnnecessaryValueParamCheck::check(const MatchFinder::MatchResult &Result) { // 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 // a ctor. - if (utils::ExprMutationAnalyzer(*Function->getBody(), *Result.Context) + if (ExprMutationAnalyzer(*Function->getBody(), *Result.Context) .isMutated(Param)) return; // CXXCtorInitializer might also mutate Param but they're not part of function // body, so check them separately here. if (const auto *Ctor = dyn_cast(Function)) { for (const auto *Init : Ctor->inits()) { - if (utils::ExprMutationAnalyzer(*Init->getInit(), *Result.Context) + if (ExprMutationAnalyzer(*Init->getInit(), *Result.Context) .isMutated(Param)) return; } diff --git a/clang-tools-extra/clang-tidy/utils/CMakeLists.txt b/clang-tools-extra/clang-tidy/utils/CMakeLists.txt index 487b09ac8f25..9162bce1e29f 100644 --- a/clang-tools-extra/clang-tidy/utils/CMakeLists.txt +++ b/clang-tools-extra/clang-tidy/utils/CMakeLists.txt @@ -3,7 +3,6 @@ set(LLVM_LINK_COMPONENTS support) add_clang_library(clangTidyUtils ASTUtils.cpp DeclRefExprUtils.cpp - ExprMutationAnalyzer.cpp ExprSequence.cpp FixItHintUtils.cpp HeaderFileExtensionsUtils.cpp diff --git a/clang-tools-extra/clang-tidy/utils/ExprMutationAnalyzer.cpp b/clang-tools-extra/clang-tidy/utils/ExprMutationAnalyzer.cpp deleted file mode 100644 index e04ac724c849..000000000000 --- a/clang-tools-extra/clang-tidy/utils/ExprMutationAnalyzer.cpp +++ /dev/null @@ -1,313 +0,0 @@ -//===---------- 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, InnerMatcher) { - const DeclStmt *const Range = Node.getRangeStmt(); - return InnerMatcher.matches(*Range, Finder, Builder); -} - -const ast_matchers::internal::VariadicDynCastAllOfMatcher - cxxTypeidExpr; - -AST_MATCHER(CXXTypeidExpr, isPotentiallyEvaluated) { - return Node.isPotentiallyEvaluated(); -} - -const ast_matchers::internal::VariadicDynCastAllOfMatcher - cxxNoexceptExpr; - -const ast_matchers::internal::VariadicDynCastAllOfMatcher - genericSelectionExpr; - -AST_MATCHER_P(GenericSelectionExpr, hasControllingExpr, - ast_matchers::internal::Matcher, 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", - 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 Matches) { - for (const auto &Nodes : Matches) { - if (const Stmt *S = findMutation(Nodes.getNodeAs("expr"))) - return S; - } - return nullptr; -} - -const Stmt * -ExprMutationAnalyzer::findDeclMutation(ArrayRef Matches) { - for (const auto &DeclNodes : Matches) { - if (const Stmt *S = findDeclMutation(DeclNodes.getNodeAs("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"); - 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 . - 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 . - // For returning by const-ref there will be an ImplicitCastExpr (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", 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 diff --git a/clang-tools-extra/clang-tidy/utils/ExprMutationAnalyzer.h b/clang-tools-extra/clang-tidy/utils/ExprMutationAnalyzer.h deleted file mode 100644 index e295de9bb880..000000000000 --- a/clang-tools-extra/clang-tidy/utils/ExprMutationAnalyzer.h +++ /dev/null @@ -1,56 +0,0 @@ -//===---------- 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 - -#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 Matches); - const Stmt *findDeclMutation(ArrayRef 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 Results; -}; - -} // namespace utils -} // namespace tidy -} // namespace clang - -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_EXPRMUTATIONANALYZER_H diff --git a/clang-tools-extra/unittests/clang-tidy/CMakeLists.txt b/clang-tools-extra/unittests/clang-tidy/CMakeLists.txt index a678e59c651d..c56445371d9a 100644 --- a/clang-tools-extra/unittests/clang-tidy/CMakeLists.txt +++ b/clang-tools-extra/unittests/clang-tidy/CMakeLists.txt @@ -9,7 +9,6 @@ include_directories(${CLANG_LINT_SOURCE_DIR}) add_extra_unittest(ClangTidyTests ClangTidyDiagnosticConsumerTest.cpp ClangTidyOptionsTest.cpp - ExprMutationAnalyzerTest.cpp IncludeInserterTest.cpp GoogleModuleTest.cpp LLVMModuleTest.cpp diff --git a/clang-tools-extra/unittests/clang-tidy/ExprMutationAnalyzerTest.cpp b/clang-tools-extra/unittests/clang-tidy/ExprMutationAnalyzerTest.cpp deleted file mode 100644 index 7f4a4cc545b3..000000000000 --- a/clang-tools-extra/unittests/clang-tidy/ExprMutationAnalyzerTest.cpp +++ /dev/null @@ -1,947 +0,0 @@ -//===---------- 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 - -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; -using StmtMatcher = internal::Matcher; - -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 &Results, ASTUnit *AST) { - const auto *const S = selectFirst("stmt", Results); - const auto *const E = selectFirst("expr", Results); - return utils::ExprMutationAnalyzer(*S, AST->getASTContext()).isMutated(E); -} - -SmallVector -mutatedBy(const SmallVectorImpl &Results, ASTUnit *AST) { - const auto *const S = selectFirst("stmt", Results); - SmallVector Chain; - utils::ExprMutationAnalyzer Analyzer(*S, AST->getASTContext()); - for (const auto *E = selectFirst("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(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 {}; - -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 {}; - -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 void mf(); };" - "template void f() { X x; x.mf(); }", - {"-fno-delayed-template-parsing"}); - auto Results = - match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); - EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf()")); - - AST = tooling::buildASTFromCodeWithArgs( - "template 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 struct X;" - "template void f() { X 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 using TRef = T&;" - "void g(TRef); 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 struct identity { using type = T; };" - "template void g(typename identity::type);" - "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;" - "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 using CTRef = const T&;" - "void g(CTRef); void f() { int x; g(x); }"); - Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); - EXPECT_FALSE(isMutated(Results, AST.get())); - - AST = tooling::buildASTFromCode( - "template struct identity { using type = T; };" - "template " - "void g(typename identity::type);" - "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, ByNonConstRRefArgument) { - auto AST = tooling::buildASTFromCode( - "void g(int&&); void f() { int x; g(static_cast(x)); }"); - auto Results = - match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); - EXPECT_THAT(mutatedBy(Results, AST.get()), - ElementsAre("g(static_cast(x))")); - - AST = tooling::buildASTFromCode( - "void f() { struct A {}; A operator+(A&&, int); " - "A x; static_cast(x) + 1; }"); - Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); - EXPECT_THAT(mutatedBy(Results, AST.get()), - ElementsAre("static_cast(x) + 1")); - - AST = tooling::buildASTFromCode("void f() { struct A { A(int&&); }; " - "int x; A y(static_cast(x)); }"); - Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); - EXPECT_THAT(mutatedBy(Results, AST.get()), - ElementsAre("static_cast(x)")); - - AST = tooling::buildASTFromCode("void f() { struct A { A(); A(A&&); }; " - "A x; A y(static_cast(x)); }"); - Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); - EXPECT_THAT(mutatedBy(Results, AST.get()), - ElementsAre("static_cast(x)")); -} - -TEST(ExprMutationAnalyzerTest, ByConstRRefArgument) { - auto AST = tooling::buildASTFromCode( - "void g(const int&&); void f() { int x; g(static_cast(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(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(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(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 struct remove_reference { typedef T type; };" - "template struct remove_reference { typedef T type; };" - "template struct remove_reference { typedef T type; };" - "template typename std::remove_reference::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 struct remove_reference { typedef T type; };" - "template struct remove_reference { typedef T type; };" - "template struct remove_reference { typedef T type; };" - "template T&& " - "forward(typename std::remove_reference::type&) noexcept;" - "template T&& " - "forward(typename std::remove_reference::type&&) noexcept;" - "void f() { struct A {}; A x; std::forward(x); }"); - const auto Results = - match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); - EXPECT_THAT(mutatedBy(Results, AST.get()), - ElementsAre("std::forward(x)")); -} - -TEST(ExprMutationAnalyzerTest, CallUnresolved) { - auto AST = tooling::buildASTFromCodeWithArgs( - "template 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 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 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 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 struct S;" - "template void f() { S 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 void mf(); };" - "template void f(S 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("template " - "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 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(x); }"); - const auto Results = - match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); - EXPECT_THAT(mutatedBy(Results, AST.get()), - ElementsAre("return static_cast(x);")); -} - -TEST(ExprMutationAnalyzerTest, ReturnAsConstRRef) { - const auto AST = tooling::buildASTFromCode( - "const int&& f() { int x; return static_cast(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 struct S { static constexpr int v = 8; };" - "template <> struct S { static constexpr int v = 4; };" - "void g(char*);" - "template void f() { char x[S::v]; g(x); }" - "template <> void f() { char y[S::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 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 struct S;" - "template void f() { S 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 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 struct S;" - "template void f() { S 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(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(x) = 10; }"); - auto Results = - match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); - EXPECT_THAT(mutatedBy(Results, AST.get()), - ElementsAre("static_cast(x) = 10")); - - AST = tooling::buildASTFromCode( - "typedef int& IntRef;" - "void f() { int x; static_cast(x) = 10; }"); - Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); - EXPECT_THAT(mutatedBy(Results, AST.get()), - ElementsAre("static_cast(x) = 10")); -} - -TEST(ExprMutationAnalyzerTest, CastToRefNotModified) { - const auto AST = - tooling::buildASTFromCode("void f() { int x; static_cast(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(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(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 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 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 x; *x; }"); - Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); - EXPECT_FALSE(isMutated(Results, AST.get())); - - AST = tooling::buildASTFromCode(UniquePtrDef + - "void f() { UniquePtr 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 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 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 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 x; x->mf(); }"); - Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); - EXPECT_FALSE(isMutated(Results, AST.get())); - - AST = tooling::buildASTFromCodeWithArgs( - UniquePtrDef + "template void f() { UniquePtr 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