<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<style type="text/css" style="display:none;"><!-- P {margin-top:0;margin-bottom:0;} --></style>
</head>
<body dir="ltr">
<div id="divtagdefaultwrapper" style="font-size: 10pt; color: rgb(0, 0, 0); font-family: Calibri, Helvetica, sans-serif, EmojiFont, "Apple Color Emoji", "Segoe UI Emoji", NotoColorEmoji, "Segoe UI Symbol", "Android Emoji", EmojiSymbols;" dir="ltr">
<p style="margin-top:0;margin-bottom:0"></p>
<p style="font-family: Calibri, Helvetica, sans-serif, EmojiFont, "Apple Color Emoji", "Segoe UI Emoji", NotoColorEmoji, "Segoe UI Symbol", "Android Emoji", EmojiSymbols; font-size: 13.3333px;">
Hello!</p>
<p style="font-family: Calibri, Helvetica, sans-serif, EmojiFont, "Apple Color Emoji", "Segoe UI Emoji", NotoColorEmoji, "Segoe UI Symbol", "Android Emoji", EmojiSymbols; font-size: 13.3333px;">
<br>
</p>
<p style="font-family: Calibri, Helvetica, sans-serif, EmojiFont, "Apple Color Emoji", "Segoe UI Emoji", NotoColorEmoji, "Segoe UI Symbol", "Android Emoji", EmojiSymbols; font-size: 13.3333px;">
You have some code in here that looks like</p>
<p style="font-family: Calibri, Helvetica, sans-serif, EmojiFont, "Apple Color Emoji", "Segoe UI Emoji", NotoColorEmoji, "Segoe UI Symbol", "Android Emoji", EmojiSymbols; font-size: 13.3333px;">
<span style="color: rgb(33, 33, 33); font-family: wf_segoe-ui_normal, "Segoe UI", "Segoe WP", Tahoma, Arial, sans-serif, serif, EmojiFont; font-size: 14.6667px;"> A operator+(A&&, int) {}</span><br>
</p>
<p style="font-family: Calibri, Helvetica, sans-serif, EmojiFont, "Apple Color Emoji", "Segoe UI Emoji", NotoColorEmoji, "Segoe UI Symbol", "Android Emoji", EmojiSymbols; font-size: 13.3333px;">
<br>
</p>
<p style="font-family: Calibri, Helvetica, sans-serif, EmojiFont, "Apple Color Emoji", "Segoe UI Emoji", NotoColorEmoji, "Segoe UI Symbol", "Android Emoji", EmojiSymbols; font-size: 13.3333px;">
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 <span style="color: rgb(33, 33, 33); font-family: wf_segoe-ui_normal, "Segoe UI", "Segoe WP", Tahoma, Arial, sans-serif, serif, EmojiFont; font-size: 14.6667px;">A
operator+(A&&, int);</span>? or will that cause you problems in other places?</p>
<p style="font-family: Calibri, Helvetica, sans-serif, EmojiFont, "Apple Color Emoji", "Segoe UI Emoji", NotoColorEmoji, "Segoe UI Symbol", "Android Emoji", EmojiSymbols; font-size: 13.3333px;">
<br>
</p>
<p style="font-family: Calibri, Helvetica, sans-serif, EmojiFont, "Apple Color Emoji", "Segoe UI Emoji", NotoColorEmoji, "Segoe UI Symbol", "Android Emoji", EmojiSymbols; font-size: 13.3333px;">
Cheers</p>
<p style="font-family: Calibri, Helvetica, sans-serif, EmojiFont, "Apple Color Emoji", "Segoe UI Emoji", NotoColorEmoji, "Segoe UI Symbol", "Android Emoji", EmojiSymbols; font-size: 13.3333px;">
Dave</p>
<br>
<p></p>
<br>
<br>
<div style="color: rgb(0, 0, 0);"><br>
<div id="divRplyFwdMsg" dir="ltr"><font face="Calibri, sans-serif" style="font-size:11pt" color="#000000"><b>From:</b> cfe-commits <cfe-commits-bounces@lists.llvm.org> on behalf of Shuai Wang via cfe-commits <cfe-commits@lists.llvm.org><br>
<b>Sent:</b> 19 September 2018 04:50<br>
<b>To:</b> cfe-commits@lists.llvm.org<br>
<b>Subject:</b> r342525 - [NFC] Fix uncompilable test cases of ExprMutationAnalyzer.</font>
<div> </div>
</div>
<div class="BodyFragment"><font size="2"><span style="font-size:11pt;">
<div class="PlainText">Author: shuaiwang<br>
Date: Tue Sep 18 20:50:03 2018<br>
New Revision: 342525<br>
<br>
URL: <a href="http://llvm.org/viewvc/llvm-project?rev=342525&view=rev">http://llvm.org/viewvc/llvm-project?rev=342525&view=rev</a><br>
Log:<br>
[NFC] Fix uncompilable test cases of ExprMutationAnalyzer.<br>
<br>
And ensure future test cases doesn't have compile errors.<br>
<br>
Modified:<br>
cfe/trunk/unittests/Analysis/ExprMutationAnalyzerTest.cpp<br>
<br>
Modified: cfe/trunk/unittests/Analysis/ExprMutationAnalyzerTest.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/unittests/Analysis/ExprMutationAnalyzerTest.cpp?rev=342525&r1=342524&r2=342525&view=diff">
http://llvm.org/viewvc/llvm-project/cfe/trunk/unittests/Analysis/ExprMutationAnalyzerTest.cpp?rev=342525&r1=342524&r2=342525&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/unittests/Analysis/ExprMutationAnalyzerTest.cpp (original)<br>
+++ cfe/trunk/unittests/Analysis/ExprMutationAnalyzerTest.cpp Tue Sep 18 20:50:03 2018<br>
@@ -29,6 +29,18 @@ namespace {<br>
using ExprMatcher = internal::Matcher<Expr>;<br>
using StmtMatcher = internal::Matcher<Stmt>;<br>
<br>
+std::unique_ptr<ASTUnit><br>
+buildASTFromCodeWithArgs(const Twine &Code,<br>
+ const std::vector<std::string> &Args) {<br>
+ auto AST = tooling::buildASTFromCodeWithArgs(Code, Args);<br>
+ EXPECT_FALSE(AST->getDiagnostics().hasErrorOccurred());<br>
+ return AST;<br>
+}<br>
+<br>
+std::unique_ptr<ASTUnit> buildASTFromCode(const Twine &Code) {<br>
+ return buildASTFromCodeWithArgs(Code, {});<br>
+}<br>
+<br>
ExprMatcher declRefTo(StringRef Name) {<br>
return declRefExpr(to(namedDecl(hasName(Name))));<br>
}<br>
@@ -83,12 +95,12 @@ const std::string StdForward =<br>
"template<class T> T&& "<br>
"forward(typename remove_reference<T>::type& t) noexcept { return t; }"<br>
"template<class T> T&& "<br>
- "forward(typename remove_reference<T>::type&&) noexcept { return t; } }";<br>
+ "forward(typename remove_reference<T>::type&& t) noexcept { return t; } }";<br>
<br>
} // namespace<br>
<br>
TEST(ExprMutationAnalyzerTest, Trivial) {<br>
- const auto AST = tooling::buildASTFromCode("void f() { int x; x; }");<br>
+ const auto AST = buildASTFromCode("void f() { int x; x; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
@@ -98,8 +110,7 @@ class AssignmentTest : public ::testing:<br>
<br>
TEST_P(AssignmentTest, AssignmentModifies) {<br>
const std::string ModExpr = "x " + GetParam() + " 10";<br>
- const auto AST =<br>
- tooling::buildASTFromCode("void f() { int x; " + ModExpr + "; }");<br>
+ const auto AST = buildASTFromCode("void f() { int x; " + ModExpr + "; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre(ModExpr));<br>
@@ -113,8 +124,7 @@ class IncDecTest : public ::testing::Tes<br>
<br>
TEST_P(IncDecTest, IncDecModifies) {<br>
const std::string ModExpr = GetParam();<br>
- const auto AST =<br>
- tooling::buildASTFromCode("void f() { int x; " + ModExpr + "; }");<br>
+ const auto AST = buildASTFromCode("void f() { int x; " + ModExpr + "; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre(ModExpr));<br>
@@ -124,7 +134,7 @@ INSTANTIATE_TEST_CASE_P(AllIncDecOperato<br>
Values("++x", "--x", "x++", "x--"), );<br>
<br>
TEST(ExprMutationAnalyzerTest, NonConstMemberFunc) {<br>
- const auto AST = tooling::buildASTFromCode(<br>
+ const auto AST = buildASTFromCode(<br>
"void f() { struct Foo { void mf(); }; Foo x; x.mf(); }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
@@ -132,7 +142,7 @@ TEST(ExprMutationAnalyzerTest, NonConstM<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, AssumedNonConstMemberFunc) {<br>
- auto AST = tooling::buildASTFromCodeWithArgs(<br>
+ auto AST = buildASTFromCodeWithArgs(<br>
"struct X { template <class T> void mf(); };"<br>
"template <class T> void f() { X x; x.mf<T>(); }",<br>
{"-fno-delayed-template-parsing"});<br>
@@ -140,13 +150,12 @@ TEST(ExprMutationAnalyzerTest, AssumedNo<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf<T>()"));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs(<br>
- "template <class T> void f() { T x; x.mf(); }",<br>
- {"-fno-delayed-template-parsing"});<br>
+ AST = buildASTFromCodeWithArgs("template <class T> void f() { T x; x.mf(); }",<br>
+ {"-fno-delayed-template-parsing"});<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf()"));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs(<br>
+ AST = buildASTFromCodeWithArgs(<br>
"template <class T> struct X;"<br>
"template <class T> void f() { X<T> x; x.mf(); }",<br>
{"-fno-delayed-template-parsing"});<br>
@@ -155,7 +164,7 @@ TEST(ExprMutationAnalyzerTest, AssumedNo<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ConstMemberFunc) {<br>
- const auto AST = tooling::buildASTFromCode(<br>
+ const auto AST = buildASTFromCode(<br>
"void f() { struct Foo { void mf() const; }; Foo x; x.mf(); }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
@@ -163,7 +172,7 @@ TEST(ExprMutationAnalyzerTest, ConstMemb<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, NonConstOperator) {<br>
- const auto AST = tooling::buildASTFromCode(<br>
+ const auto AST = buildASTFromCode(<br>
"void f() { struct Foo { Foo& operator=(int); }; Foo x; x = 10; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
@@ -171,7 +180,7 @@ TEST(ExprMutationAnalyzerTest, NonConstO<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ConstOperator) {<br>
- const auto AST = tooling::buildASTFromCode(<br>
+ const auto AST = buildASTFromCode(<br>
"void f() { struct Foo { int operator()() const; }; Foo x; x(); }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
@@ -179,280 +188,254 @@ TEST(ExprMutationAnalyzerTest, ConstOper<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ByValueArgument) {<br>
- auto AST =<br>
- tooling::buildASTFromCode("void g(int); void f() { int x; g(x); }");<br>
+ auto AST = buildASTFromCode("void g(int); void f() { int x; g(x); }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode("void g(int*); void f() { int* x; g(x); }");<br>
+ AST = buildASTFromCode("void g(int*); void f() { int* x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode("typedef int* IntPtr;"<br>
- "void g(IntPtr); void f() { int* x; g(x); }");<br>
+ AST = buildASTFromCode("typedef int* IntPtr;"<br>
+ "void g(IntPtr); void f() { int* x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { struct A {}; A operator+(A, int); A x; x + 1; }");<br>
+ AST = buildASTFromCode(<br>
+ "struct A {}; A operator+(A, int) {} void f() { A x; x + 1; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { struct A { A(int); }; int x; A y(x); }");<br>
+ AST = buildASTFromCode("void f() { struct A { A(int); }; int x; A y(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { struct A { A(); A(A); }; A x; A y(x); }");<br>
+ AST = buildASTFromCode("struct A { A(); A& operator=(A); };"<br>
+ "void f() { A x, y; y = x; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ByConstValueArgument) {<br>
- auto AST =<br>
- tooling::buildASTFromCode("void g(const int); void f() { int x; g(x); }");<br>
+ auto AST = buildASTFromCode("void g(const int); void f() { int x; g(x); }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void g(int* const); void f() { int* x; g(x); }");<br>
+ AST = buildASTFromCode("void g(int* const); void f() { int* x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST =<br>
- tooling::buildASTFromCode("typedef int* const CIntPtr;"<br>
- "void g(CIntPtr); void f() { int* x; g(x); }");<br>
+ AST = buildASTFromCode("typedef int* const CIntPtr;"<br>
+ "void g(CIntPtr); void f() { int* x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { struct A {}; A operator+(const A, int); A x; x + 1; }");<br>
+ AST = buildASTFromCode(<br>
+ "struct A {}; A operator+(const A, int) {} void f() { A x; x + 1; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
+ AST = buildASTFromCode(<br>
"void f() { struct A { A(const int); }; int x; A y(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
-<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { struct A { A(); A(const A); }; A x; A y(x); }");<br>
- Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
- EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ByNonConstRefArgument) {<br>
- auto AST =<br>
- tooling::buildASTFromCode("void g(int&); void f() { int x; g(x); }");<br>
+ auto AST = buildASTFromCode("void g(int&); void f() { int x; g(x); }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));<br>
<br>
- AST = tooling::buildASTFromCode("typedef int& IntRef;"<br>
- "void g(IntRef); void f() { int x; g(x); }");<br>
+ AST = buildASTFromCode("typedef int& IntRef;"<br>
+ "void g(IntRef); void f() { int x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));<br>
<br>
- AST =<br>
- tooling::buildASTFromCode("template <class T> using TRef = T&;"<br>
- "void g(TRef<int>); void f() { int x; g(x); }");<br>
+ AST = buildASTFromCode("template <class T> using TRef = T&;"<br>
+ "void g(TRef<int>); void f() { int x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
+ AST = buildASTFromCode(<br>
"template <class T> struct identity { using type = T; };"<br>
"template <class T, class U = T&> void g(typename identity<U>::type);"<br>
"void f() { int x; g<int>(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g<int>(x)"));<br>
<br>
- AST =<br>
- tooling::buildASTFromCode("typedef int* IntPtr;"<br>
- "void g(IntPtr&); void f() { int* x; g(x); }");<br>
+ AST = buildASTFromCode("typedef int* IntPtr;"<br>
+ "void g(IntPtr&); void f() { int* x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "typedef int* IntPtr; typedef IntPtr& IntPtrRef;"<br>
- "void g(IntPtrRef); void f() { int* x; g(x); }");<br>
+ AST = buildASTFromCode("typedef int* IntPtr; typedef IntPtr& IntPtrRef;"<br>
+ "void g(IntPtrRef); void f() { int* x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { struct A {}; A operator+(A&, int); A x; x + 1; }");<br>
+ AST = buildASTFromCode(<br>
+ "struct A {}; A operator+(A&, int) {} void f() { A x; x + 1; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x + 1"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { struct A { A(int&); }; int x; A y(x); }");<br>
+ AST = buildASTFromCode("void f() { struct A { A(int&); }; int x; A y(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { struct A { A(); A(A&); }; A x; A y(x); }");<br>
+ AST = buildASTFromCode("void f() { struct A { A(); A(A&); }; A x; A y(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ByConstRefArgument) {<br>
- auto AST = tooling::buildASTFromCode(<br>
- "void g(const int&); void f() { int x; g(x); }");<br>
+ auto AST = buildASTFromCode("void g(const int&); void f() { int x; g(x); }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode("typedef const int& CIntRef;"<br>
- "void g(CIntRef); void f() { int x; g(x); }");<br>
+ AST = buildASTFromCode("typedef const int& CIntRef;"<br>
+ "void g(CIntRef); void f() { int x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "template <class T> using CTRef = const T&;"<br>
- "void g(CTRef<int>); void f() { int x; g(x); }");<br>
+ AST = buildASTFromCode("template <class T> using CTRef = const T&;"<br>
+ "void g(CTRef<int>); void f() { int x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "template <class T> struct identity { using type = T; };"<br>
- "template <class T, class U = const T&>"<br>
- "void g(typename identity<U>::type);"<br>
- "void f() { int x; g<int>(x); }");<br>
+ AST =<br>
+ buildASTFromCode("template <class T> struct identity { using type = T; };"<br>
+ "template <class T, class U = const T&>"<br>
+ "void g(typename identity<U>::type);"<br>
+ "void f() { int x; g<int>(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { struct A {}; A operator+(const A&, int); A x; x + 1; }");<br>
+ AST = buildASTFromCode(<br>
+ "struct A {}; A operator+(const A&, int) {} void f() { A x; x + 1; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
+ AST = buildASTFromCode(<br>
"void f() { struct A { A(const int&); }; int x; A y(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
+ AST = buildASTFromCode(<br>
"void f() { struct A { A(); A(const A&); }; A x; A y(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ByNonConstRRefArgument) {<br>
- auto AST = tooling::buildASTFromCode(<br>
+ auto AST = buildASTFromCode(<br>
"void g(int&&); void f() { int x; g(static_cast<int &&>(x)); }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()),<br>
ElementsAre("g(static_cast<int &&>(x))"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { struct A {}; A operator+(A&&, int); "<br>
- "A x; static_cast<A &&>(x) + 1; }");<br>
+ AST = buildASTFromCode("struct A {}; A operator+(A&&, int) {}"<br>
+ "void f() { A x; static_cast<A &&>(x) + 1; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()),<br>
ElementsAre("static_cast<A &&>(x) + 1"));<br>
<br>
- AST = tooling::buildASTFromCode("void f() { struct A { A(int&&); }; "<br>
- "int x; A y(static_cast<int &&>(x)); }");<br>
+ AST = buildASTFromCode("void f() { struct A { A(int&&); }; "<br>
+ "int x; A y(static_cast<int &&>(x)); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()),<br>
ElementsAre("static_cast<int &&>(x)"));<br>
<br>
- AST = tooling::buildASTFromCode("void f() { struct A { A(); A(A&&); }; "<br>
- "A x; A y(static_cast<A &&>(x)); }");<br>
+ AST = buildASTFromCode("void f() { struct A { A(); A(A&&); }; "<br>
+ "A x; A y(static_cast<A &&>(x)); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()),<br>
ElementsAre("static_cast<A &&>(x)"));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ByConstRRefArgument) {<br>
- auto AST = tooling::buildASTFromCode(<br>
+ auto AST = buildASTFromCode(<br>
"void g(const int&&); void f() { int x; g(static_cast<int&&>(x)); }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { struct A {}; A operator+(const A&&, int); "<br>
- "A x; static_cast<A&&>(x) + 1; }");<br>
+ AST = buildASTFromCode("struct A {}; A operator+(const A&&, int) {}"<br>
+ "void f() { A x; static_cast<A&&>(x) + 1; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode("void f() { struct A { A(const int&&); }; "<br>
- "int x; A y(static_cast<int&&>(x)); }");<br>
+ AST = buildASTFromCode("void f() { struct A { A(const int&&); }; "<br>
+ "int x; A y(static_cast<int&&>(x)); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode("void f() { struct A { A(); A(const A&&); }; "<br>
- "A x; A y(static_cast<A&&>(x)); }");<br>
+ AST = buildASTFromCode("void f() { struct A { A(); A(const A&&); }; "<br>
+ "A x; A y(static_cast<A&&>(x)); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, Move) {<br>
- auto AST =<br>
- tooling::buildASTFromCode(StdRemoveReference + StdMove +<br>
- "void f() { struct A {}; A x; std::move(x); }");<br>
+ auto AST = buildASTFromCode(StdRemoveReference + StdMove +<br>
+ "void f() { struct A {}; A x; std::move(x); }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- StdRemoveReference + StdMove +<br>
- "void f() { struct A {}; A x, y; std::move(x) = y; }");<br>
+ AST = buildASTFromCode(StdRemoveReference + StdMove +<br>
+ "void f() { struct A {}; A x, y; std::move(x) = y; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("std::move(x) = y"));<br>
<br>
- AST = tooling::buildASTFromCode(StdRemoveReference + StdMove +<br>
- "void f() { int x, y; y = std::move(x); }");<br>
+ AST = buildASTFromCode(StdRemoveReference + StdMove +<br>
+ "void f() { int x, y; y = std::move(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- StdRemoveReference + StdMove +<br>
- "struct S { S(); S(const S&); S& operator=(const S&); };"<br>
- "void f() { S x, y; y = std::move(x); }");<br>
+ AST =<br>
+ buildASTFromCode(StdRemoveReference + StdMove +<br>
+ "struct S { S(); S(const S&); S& operator=(const S&); };"<br>
+ "void f() { S x, y; y = std::move(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST =<br>
- tooling::buildASTFromCode(StdRemoveReference + StdMove +<br>
- "struct S { S(); S(S&&); S& operator=(S&&); };"<br>
- "void f() { S x, y; y = std::move(x); }");<br>
+ AST = buildASTFromCode(StdRemoveReference + StdMove +<br>
+ "struct S { S(); S(S&&); S& operator=(S&&); };"<br>
+ "void f() { S x, y; y = std::move(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("y = std::move(x)"));<br>
<br>
- AST =<br>
- tooling::buildASTFromCode(StdRemoveReference + StdMove +<br>
- "struct S { S(); S(const S&); S(S&&);"<br>
- "S& operator=(const S&); S& operator=(S&&); };"<br>
- "void f() { S x, y; y = std::move(x); }");<br>
+ AST = buildASTFromCode(StdRemoveReference + StdMove +<br>
+ "struct S { S(); S(const S&); S(S&&);"<br>
+ "S& operator=(const S&); S& operator=(S&&); };"<br>
+ "void f() { S x, y; y = std::move(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("y = std::move(x)"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- StdRemoveReference + StdMove +<br>
- "struct S { S(); S(const S&); S(S&&);"<br>
- "S& operator=(const S&); S& operator=(S&&); };"<br>
- "void f() { const S x; S y; y = std::move(x); }");<br>
+ AST = buildASTFromCode(StdRemoveReference + StdMove +<br>
+ "struct S { S(); S(const S&); S(S&&);"<br>
+ "S& operator=(const S&); S& operator=(S&&); };"<br>
+ "void f() { const S x; S y; y = std::move(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(StdRemoveReference + StdMove +<br>
- "struct S { S(); S(S); S& operator=(S); };"<br>
- "void f() { S x, y; y = std::move(x); }");<br>
+ AST = buildASTFromCode(StdRemoveReference + StdMove +<br>
+ "struct S { S(); S& operator=(S); };"<br>
+ "void f() { S x, y; y = std::move(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- StdRemoveReference + StdMove +<br>
- "struct S{}; void f() { S x, y; y = std::move(x); }");<br>
+ AST = buildASTFromCode(StdRemoveReference + StdMove +<br>
+ "struct S{}; void f() { S x, y; y = std::move(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("y = std::move(x)"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
+ AST = buildASTFromCode(<br>
StdRemoveReference + StdMove +<br>
"struct S{}; void f() { const S x; S y; y = std::move(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
@@ -460,14 +443,14 @@ TEST(ExprMutationAnalyzerTest, Move) {<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, Forward) {<br>
- auto AST = tooling::buildASTFromCode(<br>
- StdRemoveReference + StdForward +<br>
- "void f() { struct A {}; A x; std::forward<A &>(x); }");<br>
+ auto AST =<br>
+ buildASTFromCode(StdRemoveReference + StdForward +<br>
+ "void f() { struct A {}; A x; std::forward<A &>(x); }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
+ AST = buildASTFromCode(<br>
StdRemoveReference + StdForward +<br>
"void f() { struct A {}; A x, y; std::forward<A &>(x) = y; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
@@ -476,52 +459,52 @@ TEST(ExprMutationAnalyzerTest, Forward)<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, CallUnresolved) {<br>
- auto AST = tooling::buildASTFromCodeWithArgs(<br>
- "template <class T> void f() { T x; g(x); }",<br>
- {"-fno-delayed-template-parsing"});<br>
+ auto AST =<br>
+ buildASTFromCodeWithArgs("template <class T> void f() { T x; g(x); }",<br>
+ {"-fno-delayed-template-parsing"});<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs(<br>
- "template <int N> void f() { char x[N]; g(x); }",<br>
- {"-fno-delayed-template-parsing"});<br>
+ AST =<br>
+ buildASTFromCodeWithArgs("template <int N> void f() { char x[N]; g(x); }",<br>
+ {"-fno-delayed-template-parsing"});<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs(<br>
+ AST = buildASTFromCodeWithArgs(<br>
"template <class T> void f(T t) { int x; g(t, x); }",<br>
{"-fno-delayed-template-parsing"});<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(t, x)"));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs(<br>
+ AST = buildASTFromCodeWithArgs(<br>
"template <class T> void f(T t) { int x; t.mf(x); }",<br>
{"-fno-delayed-template-parsing"});<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("t.mf(x)"));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs(<br>
+ AST = buildASTFromCodeWithArgs(<br>
"template <class T> struct S;"<br>
"template <class T> void f() { S<T> s; int x; s.mf(x); }",<br>
{"-fno-delayed-template-parsing"});<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("s.mf(x)"));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs(<br>
+ AST = buildASTFromCodeWithArgs(<br>
"struct S { template <class T> void mf(); };"<br>
"template <class T> void f(S s) { int x; s.mf<T>(x); }",<br>
{"-fno-delayed-template-parsing"});<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("s.mf<T>(x)"));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs("template <class F>"<br>
- "void g(F f) { int x; f(x); } ",<br>
- {"-fno-delayed-template-parsing"});<br>
+ AST = buildASTFromCodeWithArgs("template <class F>"<br>
+ "void g(F f) { int x; f(x); } ",<br>
+ {"-fno-delayed-template-parsing"});<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("f(x)"));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs(<br>
+ AST = buildASTFromCodeWithArgs(<br>
"template <class T> void f() { int x; (void)T(x); }",<br>
{"-fno-delayed-template-parsing"});<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
@@ -529,39 +512,38 @@ TEST(ExprMutationAnalyzerTest, CallUnres<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ReturnAsValue) {<br>
- auto AST = tooling::buildASTFromCode("int f() { int x; return x; }");<br>
+ auto AST = buildASTFromCode("int f() { int x; return x; }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode("int* f() { int* x; return x; }");<br>
+ AST = buildASTFromCode("int* f() { int* x; return x; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode("typedef int* IntPtr;"<br>
- "IntPtr f() { int* x; return x; }");<br>
+ AST = buildASTFromCode("typedef int* IntPtr;"<br>
+ "IntPtr f() { int* x; return x; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ReturnAsNonConstRef) {<br>
- const auto AST = tooling::buildASTFromCode("int& f() { int x; return x; }");<br>
+ const auto AST = buildASTFromCode("int& f() { int x; return x; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("return x;"));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ReturnAsConstRef) {<br>
- const auto AST =<br>
- tooling::buildASTFromCode("const int& f() { int x; return x; }");<br>
+ const auto AST = buildASTFromCode("const int& f() { int x; return x; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ReturnAsNonConstRRef) {<br>
- const auto AST = tooling::buildASTFromCode(<br>
- "int&& f() { int x; return static_cast<int &&>(x); }");<br>
+ const auto AST =<br>
+ buildASTFromCode("int&& f() { int x; return static_cast<int &&>(x); }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()),<br>
@@ -569,7 +551,7 @@ TEST(ExprMutationAnalyzerTest, ReturnAsN<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ReturnAsConstRRef) {<br>
- const auto AST = tooling::buildASTFromCode(<br>
+ const auto AST = buildASTFromCode(<br>
"const int&& f() { int x; return static_cast<int&&>(x); }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
@@ -577,8 +559,7 @@ TEST(ExprMutationAnalyzerTest, ReturnAsC<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, TakeAddress) {<br>
- const auto AST =<br>
- tooling::buildASTFromCode("void g(int*); void f() { int x; g(&x); }");<br>
+ const auto AST = buildASTFromCode("void g(int*); void f() { int x; g(&x); }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("&x"));<br>
@@ -586,14 +567,14 @@ TEST(ExprMutationAnalyzerTest, TakeAddre<br>
<br>
TEST(ExprMutationAnalyzerTest, ArrayToPointerDecay) {<br>
const auto AST =<br>
- tooling::buildASTFromCode("void g(int*); void f() { int x[2]; g(x); }");<br>
+ buildASTFromCode("void g(int*); void f() { int x[2]; g(x); }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, TemplateWithArrayToPointerDecay) {<br>
- const auto AST = tooling::buildASTFromCodeWithArgs(<br>
+ const auto AST = buildASTFromCodeWithArgs(<br>
"template <typename T> struct S { static constexpr int v = 8; };"<br>
"template <> struct S<int> { static constexpr int v = 4; };"<br>
"void g(char*);"<br>
@@ -609,7 +590,7 @@ TEST(ExprMutationAnalyzerTest, TemplateW<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, FollowRefModified) {<br>
- auto AST = tooling::buildASTFromCode(<br>
+ auto AST = buildASTFromCode(<br>
"void f() { int x; int& r0 = x; int& r1 = r0; int& r2 = r1; "<br>
"int& r3 = r2; r3 = 10; }");<br>
auto Results =<br>
@@ -617,40 +598,37 @@ TEST(ExprMutationAnalyzerTest, FollowRef<br>
EXPECT_THAT(mutatedBy(Results, AST.get()),<br>
ElementsAre("r0", "r1", "r2", "r3", "r3 = 10"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "typedef int& IntRefX;"<br>
- "using IntRefY = int&;"<br>
- "void f() { int x; IntRefX r0 = x; IntRefY r1 = r0;"<br>
- "decltype((x)) r2 = r1; r2 = 10; }");<br>
+ AST = buildASTFromCode("typedef int& IntRefX;"<br>
+ "using IntRefY = int&;"<br>
+ "void f() { int x; IntRefX r0 = x; IntRefY r1 = r0;"<br>
+ "decltype((x)) r2 = r1; r2 = 10; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()),<br>
ElementsAre("r0", "r1", "r2", "r2 = 10"));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, FollowRefNotModified) {<br>
- auto AST = tooling::buildASTFromCode(<br>
+ auto AST = buildASTFromCode(<br>
"void f() { int x; int& r0 = x; int& r1 = r0; int& r2 = r1; "<br>
"int& r3 = r2; int& r4 = r3; int& r5 = r4;}");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { int x; int& r0 = x; const int& r1 = r0;}");<br>
+ AST = buildASTFromCode("void f() { int x; int& r0 = x; const int& r1 = r0;}");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "typedef const int& CIntRefX;"<br>
- "using CIntRefY = const int&;"<br>
- "void f() { int x; int& r0 = x; CIntRefX r1 = r0;"<br>
- "CIntRefY r2 = r1; decltype((r1)) r3 = r2;}");<br>
+ AST = buildASTFromCode("typedef const int& CIntRefX;"<br>
+ "using CIntRefY = const int&;"<br>
+ "void f() { int x; int& r0 = x; CIntRefX r1 = r0;"<br>
+ "CIntRefY r2 = r1; decltype((r1)) r3 = r2;}");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, FollowConditionalRefModified) {<br>
- const auto AST = tooling::buildASTFromCode(<br>
+ const auto AST = buildASTFromCode(<br>
"void f() { int x, y; bool b; int &r = b ? x : y; r = 10; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
@@ -658,29 +636,28 @@ TEST(ExprMutationAnalyzerTest, FollowCon<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, FollowConditionalRefNotModified) {<br>
- const auto AST = tooling::buildASTFromCode(<br>
- "void f() { int x, y; bool b; int& r = b ? x : y; }");<br>
+ const auto AST =<br>
+ buildASTFromCode("void f() { int x, y; bool b; int& r = b ? x : y; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, FollowFuncArgModified) {<br>
- auto AST =<br>
- tooling::buildASTFromCode("template <class T> void g(T&& t) { t = 10; }"<br>
- "void f() { int x; g(x); }");<br>
+ auto AST = buildASTFromCode("template <class T> void g(T&& t) { t = 10; }"<br>
+ "void f() { int x; g(x); }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
+ AST = buildASTFromCode(<br>
"void h(int&);"<br>
"template <class... Args> void g(Args&&... args) { h(args...); }"<br>
"void f() { int x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
+ AST = buildASTFromCode(<br>
"void h(int&, int);"<br>
"template <class... Args> void g(Args&&... args) { h(args...); }"<br>
"void f() { int x, y; g(x, y); }");<br>
@@ -689,7 +666,7 @@ TEST(ExprMutationAnalyzerTest, FollowFun<br>
Results = match(withEnclosingCompound(declRefTo("y")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
+ AST = buildASTFromCode(<br>
"void h(int, int&);"<br>
"template <class... Args> void g(Args&&... args) { h(args...); }"<br>
"void f() { int x, y; g(y, x); }");<br>
@@ -698,115 +675,108 @@ TEST(ExprMutationAnalyzerTest, FollowFun<br>
Results = match(withEnclosingCompound(declRefTo("y")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "struct S { template <class T> S(T&& t) { t = 10; } };"<br>
- "void f() { int x; S s(x); }");<br>
+ AST = buildASTFromCode("struct S { template <class T> S(T&& t) { t = 10; } };"<br>
+ "void f() { int x; S s(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
+ AST = buildASTFromCode(<br>
"struct S { template <class T> S(T&& t) : m(++t) { } int m; };"<br>
"void f() { int x; S s(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- StdRemoveReference + StdForward +<br>
- "template <class... Args> void u(Args&...);"<br>
- "template <class... Args> void h(Args&&... args)"<br>
- "{ u(std::forward<Args>(args)...); }"<br>
- "template <class... Args> void g(Args&&... args)"<br>
- "{ h(std::forward<Args>(args)...); }"<br>
- "void f() { int x; g(x); }");<br>
+ AST = buildASTFromCode(StdRemoveReference + StdForward +<br>
+ "template <class... Args> void u(Args&...);"<br>
+ "template <class... Args> void h(Args&&... args)"<br>
+ "{ u(std::forward<Args>(args)...); }"<br>
+ "template <class... Args> void g(Args&&... args)"<br>
+ "{ h(std::forward<Args>(args)...); }"<br>
+ "void f() { int x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, FollowFuncArgNotModified) {<br>
- auto AST = tooling::buildASTFromCode("template <class T> void g(T&&) {}"<br>
- "void f() { int x; g(x); }");<br>
+ auto AST = buildASTFromCode("template <class T> void g(T&&) {}"<br>
+ "void f() { int x; g(x); }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode("template <class T> void g(T&& t) { t; }"<br>
- "void f() { int x; g(x); }");<br>
+ AST = buildASTFromCode("template <class T> void g(T&& t) { t; }"<br>
+ "void f() { int x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST =<br>
- tooling::buildASTFromCode("template <class... Args> void g(Args&&...) {}"<br>
- "void f() { int x; g(x); }");<br>
+ AST = buildASTFromCode("template <class... Args> void g(Args&&...) {}"<br>
+ "void f() { int x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST =<br>
- tooling::buildASTFromCode("template <class... Args> void g(Args&&...) {}"<br>
- "void f() { int y, x; g(y, x); }");<br>
+ AST = buildASTFromCode("template <class... Args> void g(Args&&...) {}"<br>
+ "void f() { int y, x; g(y, x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
+ AST = buildASTFromCode(<br>
"void h(int, int&);"<br>
"template <class... Args> void g(Args&&... args) { h(args...); }"<br>
"void f() { int x, y; g(x, y); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "struct S { template <class T> S(T&& t) { t; } };"<br>
- "void f() { int x; S s(x); }");<br>
+ AST = buildASTFromCode("struct S { template <class T> S(T&& t) { t; } };"<br>
+ "void f() { int x; S s(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
+ AST = buildASTFromCode(<br>
"struct S { template <class T> S(T&& t) : m(t) { } int m; };"<br>
"void f() { int x; S s(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- StdRemoveReference + StdForward +<br>
- "template <class... Args> void u(Args...);"<br>
- "template <class... Args> void h(Args&&... args)"<br>
- "{ u(std::forward<Args>(args)...); }"<br>
- "template <class... Args> void g(Args&&... args)"<br>
- "{ h(std::forward<Args>(args)...); }"<br>
- "void f() { int x; g(x); }");<br>
+ AST = buildASTFromCode(StdRemoveReference + StdForward +<br>
+ "template <class... Args> void u(Args...);"<br>
+ "template <class... Args> void h(Args&&... args)"<br>
+ "{ u(std::forward<Args>(args)...); }"<br>
+ "template <class... Args> void g(Args&&... args)"<br>
+ "{ h(std::forward<Args>(args)...); }"<br>
+ "void f() { int x; g(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ArrayElementModified) {<br>
- const auto AST =<br>
- tooling::buildASTFromCode("void f() { int x[2]; x[0] = 10; }");<br>
+ const auto AST = buildASTFromCode("void f() { int x[2]; x[0] = 10; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x[0] = 10"));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, ArrayElementNotModified) {<br>
- const auto AST = tooling::buildASTFromCode("void f() { int x[2]; x[0]; }");<br>
+ const auto AST = buildASTFromCode("void f() { int x[2]; x[0]; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, NestedMemberModified) {<br>
- auto AST = tooling::buildASTFromCode(<br>
- "void f() { struct A { int vi; }; struct B { A va; }; "<br>
- "struct C { B vb; }; C x; x.vb.va.vi = 10; }");<br>
+ auto AST =<br>
+ buildASTFromCode("void f() { struct A { int vi; }; struct B { A va; }; "<br>
+ "struct C { B vb; }; C x; x.vb.va.vi = 10; }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.vb.va.vi = 10"));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs(<br>
+ AST = buildASTFromCodeWithArgs(<br>
"template <class T> void f() { T x; x.y.z = 10; }",<br>
{"-fno-delayed-template-parsing"});<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.y.z = 10"));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs(<br>
+ AST = buildASTFromCodeWithArgs(<br>
"template <class T> struct S;"<br>
"template <class T> void f() { S<T> x; x.y.z = 10; }",<br>
{"-fno-delayed-template-parsing"});<br>
@@ -815,46 +785,44 @@ TEST(ExprMutationAnalyzerTest, NestedMem<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, NestedMemberNotModified) {<br>
- auto AST = tooling::buildASTFromCode(<br>
- "void f() { struct A { int vi; }; struct B { A va; }; "<br>
- "struct C { B vb; }; C x; x.vb.va.vi; }");<br>
+ auto AST =<br>
+ buildASTFromCode("void f() { struct A { int vi; }; struct B { A va; }; "<br>
+ "struct C { B vb; }; C x; x.vb.va.vi; }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs(<br>
- "template <class T> void f() { T x; x.y.z; }",<br>
- {"-fno-delayed-template-parsing"});<br>
+ AST = buildASTFromCodeWithArgs("template <class T> void f() { T x; x.y.z; }",<br>
+ {"-fno-delayed-template-parsing"});<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs(<br>
- "template <class T> struct S;"<br>
- "template <class T> void f() { S<T> x; x.y.z; }",<br>
- {"-fno-delayed-template-parsing"});<br>
+ AST =<br>
+ buildASTFromCodeWithArgs("template <class T> struct S;"<br>
+ "template <class T> void f() { S<T> x; x.y.z; }",<br>
+ {"-fno-delayed-template-parsing"});<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, CastToValue) {<br>
const auto AST =<br>
- tooling::buildASTFromCode("void f() { int x; static_cast<double>(x); }");<br>
+ buildASTFromCode("void f() { int x; static_cast<double>(x); }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, CastToRefModified) {<br>
- auto AST = tooling::buildASTFromCode(<br>
- "void f() { int x; static_cast<int &>(x) = 10; }");<br>
+ auto AST =<br>
+ buildASTFromCode("void f() { int x; static_cast<int &>(x) = 10; }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()),<br>
ElementsAre("static_cast<int &>(x) = 10"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "typedef int& IntRef;"<br>
- "void f() { int x; static_cast<IntRef>(x) = 10; }");<br>
+ AST = buildASTFromCode("typedef int& IntRef;"<br>
+ "void f() { int x; static_cast<IntRef>(x) = 10; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()),<br>
ElementsAre("static_cast<IntRef>(x) = 10"));<br>
@@ -862,45 +830,41 @@ TEST(ExprMutationAnalyzerTest, CastToRef<br>
<br>
TEST(ExprMutationAnalyzerTest, CastToRefNotModified) {<br>
const auto AST =<br>
- tooling::buildASTFromCode("void f() { int x; static_cast<int&>(x); }");<br>
+ buildASTFromCode("void f() { int x; static_cast<int&>(x); }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, CastToConstRef) {<br>
- auto AST = tooling::buildASTFromCode(<br>
- "void f() { int x; static_cast<const int&>(x); }");<br>
+ auto AST =<br>
+ buildASTFromCode("void f() { int x; static_cast<const int&>(x); }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST =<br>
- tooling::buildASTFromCode("typedef const int& CIntRef;"<br>
- "void f() { int x; static_cast<CIntRef>(x); }");<br>
+ AST = buildASTFromCode("typedef const int& CIntRef;"<br>
+ "void f() { int x; static_cast<CIntRef>(x); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, LambdaDefaultCaptureByValue) {<br>
- const auto AST =<br>
- tooling::buildASTFromCode("void f() { int x; [=]() { x = 10; }; }");<br>
+ const auto AST = buildASTFromCode("void f() { int x; [=]() { x; }; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, LambdaExplicitCaptureByValue) {<br>
- const auto AST =<br>
- tooling::buildASTFromCode("void f() { int x; [x]() { x = 10; }; }");<br>
+ const auto AST = buildASTFromCode("void f() { int x; [x]() { x; }; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, LambdaDefaultCaptureByRef) {<br>
- const auto AST =<br>
- tooling::buildASTFromCode("void f() { int x; [&]() { x = 10; }; }");<br>
+ const auto AST = buildASTFromCode("void f() { int x; [&]() { x = 10; }; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()),<br>
@@ -908,8 +872,7 @@ TEST(ExprMutationAnalyzerTest, LambdaDef<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, LambdaExplicitCaptureByRef) {<br>
- const auto AST =<br>
- tooling::buildASTFromCode("void f() { int x; [&x]() { x = 10; }; }");<br>
+ const auto AST = buildASTFromCode("void f() { int x; [&x]() { x = 10; }; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()),<br>
@@ -917,40 +880,38 @@ TEST(ExprMutationAnalyzerTest, LambdaExp<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, RangeForArrayByRefModified) {<br>
- auto AST = tooling::buildASTFromCode(<br>
- "void f() { int x[2]; for (int& e : x) e = 10; }");<br>
+ auto AST =<br>
+ buildASTFromCode("void f() { int x[2]; for (int& e : x) e = 10; }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "typedef int& IntRef;"<br>
- "void f() { int x[2]; for (IntRef e : x) e = 10; }");<br>
+ AST = buildASTFromCode("typedef int& IntRef;"<br>
+ "void f() { int x[2]; for (IntRef e : x) e = 10; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, RangeForArrayByRefNotModified) {<br>
const auto AST =<br>
- tooling::buildASTFromCode("void f() { int x[2]; for (int& e : x) e; }");<br>
+ buildASTFromCode("void f() { int x[2]; for (int& e : x) e; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, RangeForArrayByValue) {<br>
- auto AST = tooling::buildASTFromCode(<br>
- "void f() { int x[2]; for (int e : x) e = 10; }");<br>
+ auto AST = buildASTFromCode("void f() { int x[2]; for (int e : x) e = 10; }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { int* x[2]; for (int* e : x) e = nullptr; }");<br>
+ AST =<br>
+ buildASTFromCode("void f() { int* x[2]; for (int* e : x) e = nullptr; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
+ AST = buildASTFromCode(<br>
"typedef int* IntPtr;"<br>
"void f() { int* x[2]; for (IntPtr e : x) e = nullptr; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
@@ -958,39 +919,37 @@ TEST(ExprMutationAnalyzerTest, RangeForA<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, RangeForArrayByConstRef) {<br>
- auto AST = tooling::buildASTFromCode(<br>
- "void f() { int x[2]; for (const int& e : x) e; }");<br>
+ auto AST =<br>
+ buildASTFromCode("void f() { int x[2]; for (const int& e : x) e; }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "typedef const int& CIntRef;"<br>
- "void f() { int x[2]; for (CIntRef e : x) e; }");<br>
+ AST = buildASTFromCode("typedef const int& CIntRef;"<br>
+ "void f() { int x[2]; for (CIntRef e : x) e; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, RangeForNonArrayByRefModified) {<br>
const auto AST =<br>
- tooling::buildASTFromCode("struct V { int* begin(); int* end(); };"<br>
- "void f() { V x; for (int& e : x) e = 10; }");<br>
+ buildASTFromCode("struct V { int* begin(); int* end(); };"<br>
+ "void f() { V x; for (int& e : x) e = 10; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, RangeForNonArrayByRefNotModified) {<br>
- const auto AST =<br>
- tooling::buildASTFromCode("struct V { int* begin(); int* end(); };"<br>
- "void f() { V x; for (int& e : x) e; }");<br>
+ const auto AST = buildASTFromCode("struct V { int* begin(); int* end(); };"<br>
+ "void f() { V x; for (int& e : x) e; }");<br>
const auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, RangeForNonArrayByValue) {<br>
- const auto AST = tooling::buildASTFromCode(<br>
+ const auto AST = buildASTFromCode(<br>
"struct V { const int* begin() const; const int* end() const; };"<br>
"void f() { V x; for (int e : x) e; }");<br>
const auto Results =<br>
@@ -999,7 +958,7 @@ TEST(ExprMutationAnalyzerTest, RangeForN<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, RangeForNonArrayByConstRef) {<br>
- const auto AST = tooling::buildASTFromCode(<br>
+ const auto AST = buildASTFromCode(<br>
"struct V { const int* begin() const; const int* end() const; };"<br>
"void f() { V x; for (const int& e : x) e; }");<br>
const auto Results =<br>
@@ -1008,53 +967,50 @@ TEST(ExprMutationAnalyzerTest, RangeForN<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, UnevaluatedExpressions) {<br>
- auto AST = tooling::buildASTFromCode(<br>
- "void f() { int x, y; decltype(x = 10) z = y; }");<br>
+ auto AST = buildASTFromCode("void f() { int x, y; decltype(x = 10) z = y; }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { int x, y; __typeof(x = 10) z = y; }");<br>
+ AST = buildASTFromCode("void f() { int x, y; __typeof(x = 10) z = y; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- "void f() { int x, y; __typeof__(x = 10) z = y; }");<br>
+ AST = buildASTFromCode("void f() { int x, y; __typeof__(x = 10) z = y; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode("void f() { int x; sizeof(x = 10); }");<br>
+ AST = buildASTFromCode("void f() { int x; sizeof(x = 10); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode("void f() { int x; alignof(x = 10); }");<br>
+ AST = buildASTFromCode("void f() { int x; alignof(x = 10); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode("void f() { int x; noexcept(x = 10); }");<br>
+ AST = buildASTFromCode("void f() { int x; noexcept(x = 10); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs("namespace std { class type_info; }"<br>
- "void f() { int x; typeid(x = 10); }",<br>
- {"-frtti"});<br>
+ AST = buildASTFromCodeWithArgs("namespace std { class type_info; }"<br>
+ "void f() { int x; typeid(x = 10); }",<br>
+ {"-frtti"});<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
+ AST = buildASTFromCode(<br>
"void f() { int x; _Generic(x = 10, int: 0, default: 1); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
}<br>
<br>
TEST(ExprMutationAnalyzerTest, NotUnevaluatedExpressions) {<br>
- auto AST = tooling::buildASTFromCode("void f() { int x; sizeof(int[x++]); }");<br>
+ auto AST = buildASTFromCode("void f() { int x; sizeof(int[x++]); }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x++"));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs(<br>
+ AST = buildASTFromCodeWithArgs(<br>
"namespace std { class type_info; }"<br>
"struct A { virtual ~A(); }; struct B : A {};"<br>
"struct X { A& f(); }; void f() { X x; typeid(x.f()); }",<br>
@@ -1075,47 +1031,45 @@ TEST(ExprMutationAnalyzerTest, UniquePtr<br>
" T* operator->() const;"<br>
"};";<br>
<br>
- auto AST = tooling::buildASTFromCode(<br>
- UniquePtrDef + "void f() { UniquePtr<int> x; *x = 10; }");<br>
+ auto AST = buildASTFromCode(UniquePtrDef +<br>
+ "void f() { UniquePtr<int> x; *x = 10; }");<br>
auto Results =<br>
match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("* x = 10"));<br>
<br>
- AST = tooling::buildASTFromCode(UniquePtrDef +<br>
- "void f() { UniquePtr<int> x; *x; }");<br>
+ AST = buildASTFromCode(UniquePtrDef + "void f() { UniquePtr<int> x; *x; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(UniquePtrDef +<br>
- "void f() { UniquePtr<const int> x; *x; }");<br>
+ AST = buildASTFromCode(UniquePtrDef +<br>
+ "void f() { UniquePtr<const int> x; *x; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(UniquePtrDef +<br>
- "struct S { int v; };"<br>
- "void f() { UniquePtr<S> x; x->v; }");<br>
+ AST = buildASTFromCode(UniquePtrDef + "struct S { int v; };"<br>
+ "void f() { UniquePtr<S> x; x->v; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));<br>
<br>
- AST = tooling::buildASTFromCode(UniquePtrDef +<br>
- "struct S { int v; };"<br>
- "void f() { UniquePtr<const S> x; x->v; }");<br>
+ AST = buildASTFromCode(UniquePtrDef +<br>
+ "struct S { int v; };"<br>
+ "void f() { UniquePtr<const S> x; x->v; }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCode(UniquePtrDef +<br>
- "struct S { void mf(); };"<br>
- "void f() { UniquePtr<S> x; x->mf(); }");<br>
+ AST =<br>
+ buildASTFromCode(UniquePtrDef + "struct S { void mf(); };"<br>
+ "void f() { UniquePtr<S> x; x->mf(); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));<br>
<br>
- AST = tooling::buildASTFromCode(<br>
- UniquePtrDef + "struct S { void mf() const; };"<br>
- "void f() { UniquePtr<const S> x; x->mf(); }");<br>
+ AST = buildASTFromCode(UniquePtrDef +<br>
+ "struct S { void mf() const; };"<br>
+ "void f() { UniquePtr<const S> x; x->mf(); }");<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
EXPECT_FALSE(isMutated(Results, AST.get()));<br>
<br>
- AST = tooling::buildASTFromCodeWithArgs(<br>
+ AST = buildASTFromCodeWithArgs(<br>
UniquePtrDef + "template <class T> void f() { UniquePtr<T> x; x->mf(); }",<br>
{"-fno-delayed-template-parsing"});<br>
Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());<br>
<br>
<br>
_______________________________________________<br>
cfe-commits mailing list<br>
cfe-commits@lists.llvm.org<br>
<a href="http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits">http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits</a><br>
</div>
</span></font></div>
</div>
</div>
IMPORTANT NOTICE: The contents of this email and any attachments are confidential and may also be privileged. If you are not the intended recipient, please notify the sender immediately and do not disclose the contents to any other person, use it for any purpose,
or store or copy the information in any medium. Thank you.
</body>
</html>