gaijiading created this revision. gaijiading added reviewers: jlebar, Hahnfeld, dlj, tra. gaijiading added a project: clang. Herald added a subscriber: cfe-commits.
Before this patch, when a system has the CUDA toolkit already installed to its default locations in /usr/local/cuda, there will be two unexpected test case failures: 1. <clang.src>/test/Driver/cuda-detect.cu 2. <clang.src>/test/Driver/cuda-macosx.cu The reason being that the overall search order was set up to always pick up the path with well-known tools such as ptxas in it; However, the above two test cases require the CUDA path to be the one that is passed to --sysroot. Moving the sysroot path on top fixes the issue. Repository: rC Clang https://reviews.llvm.org/D52259 Files: unittests/Analysis/ExprMutationAnalyzerTest.cpp
Index: unittests/Analysis/ExprMutationAnalyzerTest.cpp =================================================================== --- unittests/Analysis/ExprMutationAnalyzerTest.cpp +++ unittests/Analysis/ExprMutationAnalyzerTest.cpp @@ -29,6 +29,18 @@ using ExprMatcher = internal::Matcher<Expr>; using StmtMatcher = internal::Matcher<Stmt>; +std::unique_ptr<ASTUnit> +buildASTFromCodeWithArgs(const Twine &Code, + const std::vector<std::string> &Args) { + auto AST = tooling::buildASTFromCodeWithArgs(Code, Args); + EXPECT_FALSE(AST->getDiagnostics().hasErrorOccurred()); + return AST; +} + +std::unique_ptr<ASTUnit> buildASTFromCode(const Twine &Code) { + return buildASTFromCodeWithArgs(Code, {}); +} + ExprMatcher declRefTo(StringRef Name) { return declRefExpr(to(namedDecl(hasName(Name)))); } @@ -83,12 +95,12 @@ "template<class T> T&& " "forward(typename remove_reference<T>::type& t) noexcept { return t; }" "template<class T> T&& " - "forward(typename remove_reference<T>::type&&) noexcept { return t; } }"; + "forward(typename remove_reference<T>::type&& t) noexcept { return t; } }"; } // namespace TEST(ExprMutationAnalyzerTest, Trivial) { - const auto AST = tooling::buildASTFromCode("void f() { int x; x; }"); + const auto AST = buildASTFromCode("void f() { int x; x; }"); const auto Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); @@ -98,8 +110,7 @@ TEST_P(AssignmentTest, AssignmentModifies) { const std::string ModExpr = "x " + GetParam() + " 10"; - const auto AST = - tooling::buildASTFromCode("void f() { int x; " + ModExpr + "; }"); + const auto AST = buildASTFromCode("void f() { int x; " + ModExpr + "; }"); const auto Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre(ModExpr)); @@ -113,8 +124,7 @@ TEST_P(IncDecTest, IncDecModifies) { const std::string ModExpr = GetParam(); - const auto AST = - tooling::buildASTFromCode("void f() { int x; " + ModExpr + "; }"); + const auto AST = buildASTFromCode("void f() { int x; " + ModExpr + "; }"); const auto Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre(ModExpr)); @@ -124,476 +134,447 @@ Values("++x", "--x", "x++", "x--"), ); TEST(ExprMutationAnalyzerTest, NonConstMemberFunc) { - const auto AST = tooling::buildASTFromCode( + const auto AST = 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( + auto AST = 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"}); + AST = 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( + AST = 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( + const auto AST = 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( + const auto AST = 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( + const auto AST = 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 AST = 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); }"); + AST = 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); }"); + AST = 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; }"); + AST = buildASTFromCode( + "struct A {}; A operator+(A, int) {} void f() { 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); }"); + AST = 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); }"); + AST = buildASTFromCode("struct A { A(); A& operator=(A); };" + "void f() { A x, y; 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 AST = 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); }"); + AST = 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); }"); + AST = 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; }"); + AST = buildASTFromCode( + "struct A {}; A operator+(const A, int) {} void f() { A x; x + 1; }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = tooling::buildASTFromCode( + AST = 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 AST = 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); }"); + AST = 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); }"); + AST = 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( + AST = 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); }"); + AST = 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); }"); + AST = 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; }"); + AST = buildASTFromCode( + "struct A {}; A operator+(A&, int) {} void f() { 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); }"); + AST = 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); }"); + AST = 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 AST = 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); }"); + AST = 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); }"); + AST = 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); }"); + AST = + 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; }"); + AST = buildASTFromCode( + "struct A {}; A operator+(const A&, int) {} void f() { A x; x + 1; }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = tooling::buildASTFromCode( + AST = 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( + AST = 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( + auto AST = 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; }"); + AST = buildASTFromCode("struct A {}; A operator+(A&&, int) {}" + "void f() { 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)); }"); + AST = 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)); }"); + AST = 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( + auto AST = 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; }"); + AST = buildASTFromCode("struct A {}; A operator+(const A&&, int) {}" + "void f() { 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)); }"); + AST = 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)); }"); + AST = 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) { - auto AST = - tooling::buildASTFromCode(StdRemoveReference + StdMove + - "void f() { struct A {}; A x; std::move(x); }"); + auto AST = buildASTFromCode(StdRemoveReference + StdMove + + "void f() { struct A {}; A x; std::move(x); }"); auto Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = tooling::buildASTFromCode( - StdRemoveReference + StdMove + - "void f() { struct A {}; A x, y; std::move(x) = y; }"); + AST = buildASTFromCode(StdRemoveReference + StdMove + + "void f() { struct A {}; A x, y; std::move(x) = y; }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("std::move(x) = y")); - AST = tooling::buildASTFromCode(StdRemoveReference + StdMove + - "void f() { int x, y; y = std::move(x); }"); + AST = buildASTFromCode(StdRemoveReference + StdMove + + "void f() { int x, y; y = std::move(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = tooling::buildASTFromCode( - StdRemoveReference + StdMove + - "struct S { S(); S(const S&); S& operator=(const S&); };" - "void f() { S x, y; y = std::move(x); }"); + AST = + buildASTFromCode(StdRemoveReference + StdMove + + "struct S { S(); S(const S&); S& operator=(const S&); };" + "void f() { S x, y; y = std::move(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = - tooling::buildASTFromCode(StdRemoveReference + StdMove + - "struct S { S(); S(S&&); S& operator=(S&&); };" - "void f() { S x, y; y = std::move(x); }"); + AST = buildASTFromCode(StdRemoveReference + StdMove + + "struct S { S(); S(S&&); S& operator=(S&&); };" + "void f() { S x, y; y = std::move(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("y = std::move(x)")); - AST = - tooling::buildASTFromCode(StdRemoveReference + StdMove + - "struct S { S(); S(const S&); S(S&&);" - "S& operator=(const S&); S& operator=(S&&); };" - "void f() { S x, y; y = std::move(x); }"); + AST = buildASTFromCode(StdRemoveReference + StdMove + + "struct S { S(); S(const S&); S(S&&);" + "S& operator=(const S&); S& operator=(S&&); };" + "void f() { S x, y; y = std::move(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("y = std::move(x)")); - AST = tooling::buildASTFromCode( - StdRemoveReference + StdMove + - "struct S { S(); S(const S&); S(S&&);" - "S& operator=(const S&); S& operator=(S&&); };" - "void f() { const S x; S y; y = std::move(x); }"); + AST = buildASTFromCode(StdRemoveReference + StdMove + + "struct S { S(); S(const S&); S(S&&);" + "S& operator=(const S&); S& operator=(S&&); };" + "void f() { const S x; S y; y = std::move(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = tooling::buildASTFromCode(StdRemoveReference + StdMove + - "struct S { S(); S(S); S& operator=(S); };" - "void f() { S x, y; y = std::move(x); }"); + AST = buildASTFromCode(StdRemoveReference + StdMove + + "struct S { S(); S& operator=(S); };" + "void f() { S x, y; y = std::move(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = tooling::buildASTFromCode( - StdRemoveReference + StdMove + - "struct S{}; void f() { S x, y; y = std::move(x); }"); + AST = buildASTFromCode(StdRemoveReference + StdMove + + "struct S{}; void f() { S x, y; y = std::move(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("y = std::move(x)")); - AST = tooling::buildASTFromCode( + AST = buildASTFromCode( StdRemoveReference + StdMove + "struct S{}; void f() { const S x; S y; y = std::move(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); } TEST(ExprMutationAnalyzerTest, Forward) { - auto AST = tooling::buildASTFromCode( - StdRemoveReference + StdForward + - "void f() { struct A {}; A x; std::forward<A &>(x); }"); + auto AST = + buildASTFromCode(StdRemoveReference + StdForward + + "void f() { struct A {}; A x; std::forward<A &>(x); }"); auto Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = tooling::buildASTFromCode( + AST = buildASTFromCode( StdRemoveReference + StdForward + "void f() { struct A {}; A x, y; std::forward<A &>(x) = y; }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("std::forward<A &>(x) = y")); } TEST(ExprMutationAnalyzerTest, CallUnresolved) { - auto AST = tooling::buildASTFromCodeWithArgs( - "template <class T> void f() { T x; g(x); }", - {"-fno-delayed-template-parsing"}); + auto AST = + 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"}); + AST = + 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( + AST = 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( + AST = 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( + AST = 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( + AST = 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"}); + AST = 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( + AST = 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 AST = 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; }"); + AST = 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; }"); + AST = 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 AST = 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 AST = 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 AST = + 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 auto AST = 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 AST = 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); }"); + 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( + const auto AST = buildASTFromCodeWithArgs( "template <typename T> struct S { static constexpr int v = 8; };" "template <> struct S<int> { static constexpr int v = 4; };" "void g(char*);" @@ -609,452 +590,427 @@ } TEST(ExprMutationAnalyzerTest, FollowRefModified) { - auto AST = tooling::buildASTFromCode( + auto AST = 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; }"); + AST = 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( + auto AST = 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;}"); + AST = 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;}"); + AST = 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( + const auto AST = 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 AST = + 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, FollowFuncArgModified) { - auto AST = - tooling::buildASTFromCode("template <class T> void g(T&& t) { t = 10; }" - "void f() { int x; g(x); }"); + auto AST = buildASTFromCode("template <class T> void g(T&& t) { t = 10; }" + "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( + AST = buildASTFromCode( "void h(int&);" "template <class... Args> void g(Args&&... args) { h(args...); }" "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( + AST = buildASTFromCode( "void h(int&, int);" "template <class... Args> void g(Args&&... args) { h(args...); }" "void f() { int x, y; g(x, y); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x, y)")); Results = match(withEnclosingCompound(declRefTo("y")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = tooling::buildASTFromCode( + AST = buildASTFromCode( "void h(int, int&);" "template <class... Args> void g(Args&&... args) { h(args...); }" "void f() { int x, y; g(y, x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(y, x)")); Results = match(withEnclosingCompound(declRefTo("y")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = tooling::buildASTFromCode( - "struct S { template <class T> S(T&& t) { t = 10; } };" - "void f() { int x; S s(x); }"); + AST = buildASTFromCode("struct S { template <class T> S(T&& t) { t = 10; } };" + "void f() { int x; S s(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x")); - AST = tooling::buildASTFromCode( + AST = buildASTFromCode( "struct S { template <class T> S(T&& t) : m(++t) { } int m; };" "void f() { int x; S s(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x")); - AST = tooling::buildASTFromCode( - StdRemoveReference + StdForward + - "template <class... Args> void u(Args&...);" - "template <class... Args> void h(Args&&... args)" - "{ u(std::forward<Args>(args)...); }" - "template <class... Args> void g(Args&&... args)" - "{ h(std::forward<Args>(args)...); }" - "void f() { int x; g(x); }"); + AST = buildASTFromCode(StdRemoveReference + StdForward + + "template <class... Args> void u(Args&...);" + "template <class... Args> void h(Args&&... args)" + "{ u(std::forward<Args>(args)...); }" + "template <class... Args> void g(Args&&... args)" + "{ h(std::forward<Args>(args)...); }" + "void f() { int x; g(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)")); } TEST(ExprMutationAnalyzerTest, FollowFuncArgNotModified) { - auto AST = tooling::buildASTFromCode("template <class T> void g(T&&) {}" - "void f() { int x; g(x); }"); + auto AST = buildASTFromCode("template <class T> void g(T&&) {}" + "void f() { int x; g(x); }"); auto Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = tooling::buildASTFromCode("template <class T> void g(T&& t) { t; }" - "void f() { int x; g(x); }"); + AST = buildASTFromCode("template <class T> void g(T&& t) { t; }" + "void f() { int x; g(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = - tooling::buildASTFromCode("template <class... Args> void g(Args&&...) {}" - "void f() { int x; g(x); }"); + AST = buildASTFromCode("template <class... Args> void g(Args&&...) {}" + "void f() { int x; g(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = - tooling::buildASTFromCode("template <class... Args> void g(Args&&...) {}" - "void f() { int y, x; g(y, x); }"); + AST = buildASTFromCode("template <class... Args> void g(Args&&...) {}" + "void f() { int y, x; g(y, x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = tooling::buildASTFromCode( + AST = buildASTFromCode( "void h(int, int&);" "template <class... Args> void g(Args&&... args) { h(args...); }" "void f() { int x, y; g(x, y); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = tooling::buildASTFromCode( - "struct S { template <class T> S(T&& t) { t; } };" - "void f() { int x; S s(x); }"); + AST = buildASTFromCode("struct S { template <class T> S(T&& t) { t; } };" + "void f() { int x; S s(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = tooling::buildASTFromCode( + AST = buildASTFromCode( "struct S { template <class T> S(T&& t) : m(t) { } int m; };" "void f() { int x; S s(x); }"); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_FALSE(isMutated(Results, AST.get())); - AST = tooling::buildASTFromCode( - StdRemoveReference + StdForward + - "template <class... Args> void u(Args...);" - "template <class... Args> void h(Args&&... args)" - "{ u(std::forward<Args>(args)...); }" - "template <class... Args> void g(Args&&... args)" - "{ h(std::forward<Args>(args)...); }" - "void f() { int x; g(x); }"); + AST = buildASTFromCode(StdRemoveReference + StdForward + + "template <class... Args> void u(Args...);" + "template <class... Args> void h(Args&&... args)" + "{ u(std::forward<Args>(args)...); }" + "template <class... Args> void g(Args&&... args)" + "{ h(std::forward<Args>(args)...); }" + "void f() { int x; g(x); }"); 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 AST = 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 AST = 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 AST = + 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( + AST = 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( + AST = 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 AST = + 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"}); + AST = 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"}); + AST = + 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); }"); + 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 AST = + 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; }"); + AST = 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); }"); + 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 AST = + 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); }"); + AST = 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 AST = buildASTFromCode("void f() { int x; [=]() { x; }; }"); 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 AST = buildASTFromCode("void f() { int x; [x]() { x; }; }"); 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 AST = 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 AST = 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 AST = + 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; }"); + AST = 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; }"); + 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 AST = 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; }"); + AST = + 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( + AST = 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 AST = + 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; }"); + AST = 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; }"); + 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 AST = 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( + const auto AST = 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( + const auto AST = 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 AST = 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; }"); + AST = 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; }"); + AST = 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); }"); + AST = 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); }"); + AST = 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); }"); + AST = 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"}); + AST = 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( + AST = 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 AST = 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( + AST = buildASTFromCodeWithArgs( "namespace std { class type_info; }" "struct A { virtual ~A(); }; struct B : A {};" "struct X { A& f(); }; void f() { X x; typeid(x.f()); }", @@ -1075,47 +1031,45 @@ " T* operator->() const;" "};"; - auto AST = tooling::buildASTFromCode( - UniquePtrDef + "void f() { UniquePtr<int> x; *x = 10; }"); + auto AST = 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; }"); + AST = 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; }"); + AST = 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; }"); + AST = 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; }"); + AST = 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(); }"); + AST = + 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(); }"); + AST = 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( + AST = buildASTFromCodeWithArgs( UniquePtrDef + "template <class T> void f() { UniquePtr<T> x; x->mf(); }", {"-fno-delayed-template-parsing"}); Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits