r342525 - [NFC] Fix uncompilable test cases of ExprMutationAnalyzer.
Shuai Wang via cfe-commits
cfe-commits at lists.llvm.org
Wed Sep 19 13:32:10 PDT 2018
On Wed, Sep 19, 2018 at 3:10 AM David Green <David.Green at arm.com> wrote:
> Hello!
>
>
> You have some code in here that looks like
>
> A operator+(A&&, int) {}
>
>
> which is a non-void function without a return statement. Any reason to use
> "{}" and not ";"? You seem to have deliberately changed them, but that
> causes us some problems downstream. Mind if we change them to A
> operator+(A&&, int);? or will that cause you problems in other places?
>
You're right, I don't need to define it, fixed in
https://reviews.llvm.org/rC342586
Thanks for pointing it out!
>
> Cheers
>
> Dave
>
>
>
>
> *From:* cfe-commits <cfe-commits-bounces at lists.llvm.org> on behalf of
> Shuai Wang via cfe-commits <cfe-commits at lists.llvm.org>
> *Sent:* 19 September 2018 04:50
> *To:* cfe-commits at lists.llvm.org
> *Subject:* r342525 - [NFC] Fix uncompilable test cases of
> ExprMutationAnalyzer.
>
> Author: shuaiwang
> Date: Tue Sep 18 20:50:03 2018
> New Revision: 342525
>
> URL: http://llvm.org/viewvc/llvm-project?rev=342525&view=rev
> Log:
> [NFC] Fix uncompilable test cases of ExprMutationAnalyzer.
>
> And ensure future test cases doesn't have compile errors.
>
> Modified:
> cfe/trunk/unittests/Analysis/ExprMutationAnalyzerTest.cpp
>
> Modified: cfe/trunk/unittests/Analysis/ExprMutationAnalyzerTest.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/unittests/Analysis/ExprMutationAnalyzerTest.cpp?rev=342525&r1=342524&r2=342525&view=diff
>
> ==============================================================================
> --- cfe/trunk/unittests/Analysis/ExprMutationAnalyzerTest.cpp (original)
> +++ cfe/trunk/unittests/Analysis/ExprMutationAnalyzerTest.cpp Tue Sep 18
> 20:50:03 2018
> @@ -29,6 +29,18 @@ namespace {
> 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 @@ const std::string StdForward =
> "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 @@ class AssignmentTest : public ::testing:
>
> 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 @@ class IncDecTest : public ::testing::Tes
>
> 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,7 +134,7 @@ INSTANTIATE_TEST_CASE_P(AllIncDecOperato
> 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());
> @@ -132,7 +142,7 @@ TEST(ExprMutationAnalyzerTest, NonConstM
> }
>
> 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"});
> @@ -140,13 +150,12 @@ TEST(ExprMutationAnalyzerTest, AssumedNo
> 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"});
> @@ -155,7 +164,7 @@ TEST(ExprMutationAnalyzerTest, AssumedNo
> }
>
> 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());
> @@ -163,7 +172,7 @@ TEST(ExprMutationAnalyzerTest, ConstMemb
> }
>
> 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());
> @@ -171,7 +180,7 @@ TEST(ExprMutationAnalyzerTest, NonConstO
> }
>
> 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());
> @@ -179,280 +188,254 @@ TEST(ExprMutationAnalyzerTest, ConstOper
> }
>
> 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());
> @@ -460,14 +443,14 @@ TEST(ExprMutationAnalyzerTest, Move) {
> }
>
> 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());
> @@ -476,52 +459,52 @@ TEST(ExprMutationAnalyzerTest, Forward)
> }
>
> 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());
> @@ -529,39 +512,38 @@ TEST(ExprMutationAnalyzerTest, CallUnres
> }
>
> 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()),
> @@ -569,7 +551,7 @@ TEST(ExprMutationAnalyzerTest, ReturnAsN
> }
>
> 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());
> @@ -577,8 +559,7 @@ TEST(ExprMutationAnalyzerTest, ReturnAsC
> }
>
> 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"));
> @@ -586,14 +567,14 @@ TEST(ExprMutationAnalyzerTest, TakeAddre
>
> 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,7 +590,7 @@ TEST(ExprMutationAnalyzerTest, TemplateW
> }
>
> 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 =
> @@ -617,40 +598,37 @@ TEST(ExprMutationAnalyzerTest, FollowRef
> 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());
> @@ -658,29 +636,28 @@ TEST(ExprMutationAnalyzerTest, FollowCon
> }
>
> 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); }");
> @@ -689,7 +666,7 @@ TEST(ExprMutationAnalyzerTest, FollowFun
> 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); }");
> @@ -698,115 +675,108 @@ TEST(ExprMutationAnalyzerTest, FollowFun
> 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"});
> @@ -815,46 +785,44 @@ TEST(ExprMutationAnalyzerTest, NestedMem
> }
>
> 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"));
> @@ -862,45 +830,41 @@ TEST(ExprMutationAnalyzerTest, CastToRef
>
> 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()),
> @@ -908,8 +872,7 @@ TEST(ExprMutationAnalyzerTest, LambdaDef
> }
>
> 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()),
> @@ -917,40 +880,38 @@ TEST(ExprMutationAnalyzerTest, LambdaExp
> }
>
> 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());
> @@ -958,39 +919,37 @@ TEST(ExprMutationAnalyzerTest, RangeForA
> }
>
> 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 =
> @@ -999,7 +958,7 @@ TEST(ExprMutationAnalyzerTest, RangeForN
> }
>
> TEST(ExprMutationAnalyzerTest, RangeForNonArrayByConstRef) {
> - const auto AST = tooling::buildASTFromCode(
> + const auto AST = buildASTFromCode(
> "struct V { const int* begin() const; const int* end() const; };
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20180919/a0ee4541/attachment-0001.html>
More information about the cfe-commits
mailing list