[CUDA] Fix two failed test cases using --cuda-path-ignore-env

[gaijiading]

Summary

Add --cuda-path-ignore-env option to those test cases to ensure the clang driver always pick the CUDA path specified by --sysroot.

[tra]

The patch does not seem to match the description and appears to have nothing to do with rearranging include paths. Could you check if these are the changes you intended to send for review.

[gaijiading]

Apologies for having uploaded the wrong patch in my original review request. Please help review this version instead. Thanks.

[Hahnfeld]

IMO the current logic makes sense for the end user, prioritizing the environment guess over default paths. I think the tests should be fixed using --cuda-path-ignore-env, I remember I added this parameter to fix the failing tests when I wrote the code.

[gaijiading]

Thanks for the comments. Revised the patch to fix them using --cuda-path-ignore-env.

[tra]

It's unfortunate that lit does not scrub the environment in order to make tests hermetic.

unittests/Analysis/ExprMutationAnalyzerTest.cpp

 using ::testing::StartsWith;
 using ::testing::Values;
 
 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))));
 }
 
 StmtMatcher withEnclosingCompound(ExprMatcher Matcher) {
   return expr(Matcher, hasAncestor(compoundStmt().bind("stmt"))).bind("expr");
 }
 
const std::string StdMove =
     "move(T&& t) noexcept {"
     "return static_cast<typename remove_reference<T>::type&&>(t); } }";
 
 const std::string StdForward =
     "namespace std {"
     "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()));
 }
 
 class AssignmentTest : public ::testing::TestWithParam<std::string> {};
 
 TEST_P(AssignmentTest, AssignmentModifies) {
   const std::string ModExpr = "x " + GetParam() + " 10";
-  const auto AST =
-      tooling::buildASTFromCode("void f() { int x; " + ModExpr + "; }");
+  const auto AST = buildASTFromCode("void f() { int x; " + ModExpr + "; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre(ModExpr));
 }
 
 INSTANTIATE_TEST_CASE_P(AllAssignmentOperators, AssignmentTest,
                         Values("=", "+=", "-=", "*=", "/=", "%=", "&=", "|=",
                                "^=", "<<=", ">>="), );
 
 class IncDecTest : public ::testing::TestWithParam<std::string> {};
 
 TEST_P(IncDecTest, IncDecModifies) {
   const std::string ModExpr = GetParam();
-  const auto AST =
-      tooling::buildASTFromCode("void f() { int x; " + ModExpr + "; }");
+  const auto AST = buildASTFromCode("void f() { int x; " + ModExpr + "; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre(ModExpr));
 }
 
 INSTANTIATE_TEST_CASE_P(AllIncDecOperators, IncDecTest,
                         Values("++x", "--x", "x++", "x--"), );
 
 TEST(ExprMutationAnalyzerTest, NonConstMemberFunc) {
-  const auto AST = tooling::buildASTFromCode(
+  const auto AST = buildASTFromCode(
       "void f() { struct Foo { void mf(); }; Foo x; x.mf(); }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf()"));
 }
 
 TEST(ExprMutationAnalyzerTest, AssumedNonConstMemberFunc) {
-  auto AST = tooling::buildASTFromCodeWithArgs(
+  auto AST = buildASTFromCodeWithArgs(
       "struct X { template <class T> void mf(); };"
       "template <class T> void f() { X x; x.mf<T>(); }",
       {"-fno-delayed-template-parsing"});
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf<T>()"));
 
-  AST = tooling::buildASTFromCodeWithArgs(
-      "template <class T> void f() { T x; x.mf(); }",
+  AST = buildASTFromCodeWithArgs("template <class T> void f() { T x; x.mf(); }",
                                  {"-fno-delayed-template-parsing"});
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf()"));
 
-  AST = tooling::buildASTFromCodeWithArgs(
+  AST = buildASTFromCodeWithArgs(
       "template <class T> struct X;"
       "template <class T> void f() { X<T> x; x.mf(); }",
       {"-fno-delayed-template-parsing"});
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf()"));
 }
 
 TEST(ExprMutationAnalyzerTest, ConstMemberFunc) {
-  const auto AST = tooling::buildASTFromCode(
+  const auto AST = buildASTFromCode(
       "void f() { struct Foo { void mf() const; }; Foo x; x.mf(); }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, NonConstOperator) {
-  const auto AST = tooling::buildASTFromCode(
+  const auto AST = buildASTFromCode(
       "void f() { struct Foo { Foo& operator=(int); }; Foo x; x = 10; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x = 10"));
 }
 
 TEST(ExprMutationAnalyzerTest, ConstOperator) {
-  const auto AST = tooling::buildASTFromCode(
+  const auto AST = buildASTFromCode(
       "void f() { struct Foo { int operator()() const; }; Foo x; x(); }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, ByValueArgument) {
-  auto AST =
-      tooling::buildASTFromCode("void g(int); void f() { int x; g(x); }");
+  auto AST = buildASTFromCode("void g(int); void f() { int x; g(x); }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode("void g(int*); void f() { int* x; g(x); }");
+  AST = buildASTFromCode("void g(int*); void f() { int* x; g(x); }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode("typedef int* IntPtr;"
-                                  "void g(IntPtr); void f() { int* x; g(x); }");
+  AST = buildASTFromCode("typedef int* IntPtr;"
   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;"
   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;"
   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&;"
   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;"
   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;"
+  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;"
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(
-      "template <class T> using CTRef = const T&;"
+  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; };"
+  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&&); }; "
   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&&); }; "
   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&&); }; "
   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&&); }; "
   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 +
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(
-      StdRemoveReference + StdMove +
+  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 +
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(
-      StdRemoveReference + StdMove +
+  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 +
   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 +
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("y = std::move(x)"));
 
-  AST = tooling::buildASTFromCode(
-      StdRemoveReference + StdMove +
+  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); };"
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(
-      StdRemoveReference + StdMove +
+  AST = buildASTFromCode(StdRemoveReference + StdMove +
                          "struct S{}; void f() { S x, y; y = std::move(x); }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("y = std::move(x)"));
 
-  AST = tooling::buildASTFromCode(
+  AST = buildASTFromCode(
       StdRemoveReference + StdMove +
       "struct S{}; void f() { const S x; S y; y = std::move(x); }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, Forward) {
-  auto AST = tooling::buildASTFromCode(
-      StdRemoveReference + StdForward +
+  auto AST =
+      buildASTFromCode(StdRemoveReference + StdForward +
                        "void f() { struct A {}; A x; std::forward<A &>(x); }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(
+  AST = buildASTFromCode(
       StdRemoveReference + StdForward +
       "void f() { struct A {}; A x, y; std::forward<A &>(x) = y; }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("std::forward<A &>(x) = y"));
 }
 
 TEST(ExprMutationAnalyzerTest, CallUnresolved) {
-  auto AST = tooling::buildASTFromCodeWithArgs(
-      "template <class T> void f() { T x; g(x); }",
+  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); }",
+  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>"
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("f(x)"));
 
-  AST = tooling::buildASTFromCodeWithArgs(
+  AST = buildASTFromCodeWithArgs(
       "template <class T> void f() { int x; (void)T(x); }",
       {"-fno-delayed-template-parsing"});
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("T(x)"));
 }
 
 TEST(ExprMutationAnalyzerTest, ReturnAsValue) {
-  auto AST = tooling::buildASTFromCode("int f() { int x; return x; }");
+  auto AST = buildASTFromCode("int f() { int x; return x; }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode("int* f() { int* x; return x; }");
+  AST = buildASTFromCode("int* f() { int* x; return x; }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode("typedef int* IntPtr;"
-                                  "IntPtr f() { int* x; return x; }");
+  AST = buildASTFromCode("typedef int* IntPtr;"
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, ReturnAsNonConstRef) {
-  const auto AST = tooling::buildASTFromCode("int& f() { int x; return x; }");
+  const auto AST = buildASTFromCode("int& f() { int x; return x; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("return x;"));
 }
 
 TEST(ExprMutationAnalyzerTest, ReturnAsConstRef) {
-  const auto AST =
-      tooling::buildASTFromCode("const int& f() { int x; return x; }");
+  const auto AST = buildASTFromCode("const int& f() { int x; return x; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, ReturnAsNonConstRRef) {
-  const auto AST = tooling::buildASTFromCode(
-      "int&& f() { int x; return static_cast<int &&>(x); }");
+  const auto AST =
+      buildASTFromCode("int&& f() { int x; return static_cast<int &&>(x); }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("return static_cast<int &&>(x);"));
 }
 
 TEST(ExprMutationAnalyzerTest, ReturnAsConstRRef) {
-  const auto AST = tooling::buildASTFromCode(
+  const auto AST = buildASTFromCode(
       "const int&& f() { int x; return static_cast<int&&>(x); }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, TakeAddress) {
-  const auto AST =
-      tooling::buildASTFromCode("void g(int*); void f() { int x; g(&x); }");
+  const auto AST = buildASTFromCode("void g(int*); void f() { int x; g(&x); }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("&x"));
 }
 
 TEST(ExprMutationAnalyzerTest, ArrayToPointerDecay) {
   const auto AST =
-      tooling::buildASTFromCode("void g(int*); void f() { int x[2]; g(x); }");
+      buildASTFromCode("void g(int*); void f() { int x[2]; g(x); }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
 }
 
 TEST(ExprMutationAnalyzerTest, TemplateWithArrayToPointerDecay) {
-  const auto AST = tooling::buildASTFromCodeWithArgs(
+  const auto AST = buildASTFromCodeWithArgs(
       "template <typename T> struct S { static constexpr int v = 8; };"
       "template <> struct S<int> { static constexpr int v = 4; };"
       "void g(char*);"
       "template <typename T> void f() { char x[S<T>::v]; g(x); }"
       "template <> void f<int>() { char y[S<int>::v]; g(y); }",
       {"-fno-delayed-template-parsing"});
   const auto ResultsX =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(ResultsX, AST.get()), ElementsAre("g(x)"));
   const auto ResultsY =
       match(withEnclosingCompound(declRefTo("y")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(ResultsY, AST.get()), ElementsAre("y"));
 }
 
 TEST(ExprMutationAnalyzerTest, FollowRefModified) {
-  auto AST = tooling::buildASTFromCode(
+  auto AST = buildASTFromCode(
       "void f() { int x; int& r0 = x; int& r1 = r0; int& r2 = r1; "
       "int& r3 = r2; r3 = 10; }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("r0", "r1", "r2", "r3", "r3 = 10"));
 
-  AST = tooling::buildASTFromCode(
-      "typedef int& IntRefX;"
+  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;"
+  AST = buildASTFromCode("typedef const int& CIntRefX;"
                          "using CIntRefY = const int&;"
                          "void f() { int x; int& r0 = x; CIntRefX r1 = r0;"
                          "CIntRefY r2 = r1; decltype((r1)) r3 = r2;}");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, FollowConditionalRefModified) {
-  const auto AST = tooling::buildASTFromCode(
+  const auto AST = buildASTFromCode(
       "void f() { int x, y; bool b; int &r = b ? x : y; r = 10; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("r", "r = 10"));
 }
 
 TEST(ExprMutationAnalyzerTest, FollowConditionalRefNotModified) {
-  const auto AST = tooling::buildASTFromCode(
-      "void f() { int x, y; bool b; int& r = b ? x : y; }");
+  const auto AST =
+      buildASTFromCode("void f() { int x, y; bool b; int& r = b ? x : y; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, FollowFuncArgModified) {
-  auto AST =
-      tooling::buildASTFromCode("template <class T> void g(T&& t) { t = 10; }"
-                                "void f() { int x; g(x); }");
+  auto AST = buildASTFromCode("template <class T> void g(T&& t) { t = 10; }"
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
 
-  AST = tooling::buildASTFromCode(
+  AST = buildASTFromCode(
       "void h(int&);"
       "template <class... Args> void g(Args&&... args) { h(args...); }"
       "void f() { int x; g(x); }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
 
-  AST = tooling::buildASTFromCode(
+  AST = buildASTFromCode(
       "void h(int&, int);"
       "template <class... Args> void g(Args&&... args) { h(args...); }"
       "void f() { int x, y; g(x, y); }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x, y)"));
   Results = match(withEnclosingCompound(declRefTo("y")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(
+  AST = buildASTFromCode(
       "void h(int, int&);"
       "template <class... Args> void g(Args&&... args) { h(args...); }"
       "void f() { int x, y; g(y, x); }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(y, x)"));
   Results = match(withEnclosingCompound(declRefTo("y")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(
-      "struct S { template <class T> S(T&& t) { t = 10; } };"
+  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 +
+  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&&) {}"
   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; }"
   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&&...) {}"
   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&&...) {}"
   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; } };"
+  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 +
+  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; }; "
+  auto AST =
+      buildASTFromCode("void f() { struct A { int vi; }; struct B { A va; }; "
                        "struct C { B vb; }; C x; x.vb.va.vi = 10; }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.vb.va.vi = 10"));
 
-  AST = tooling::buildASTFromCodeWithArgs(
+  AST = buildASTFromCodeWithArgs(
       "template <class T> void f() { T x; x.y.z = 10; }",
       {"-fno-delayed-template-parsing"});
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.y.z = 10"));
 
-  AST = tooling::buildASTFromCodeWithArgs(
+  AST = buildASTFromCodeWithArgs(
       "template <class T> struct S;"
       "template <class T> void f() { S<T> x; x.y.z = 10; }",
       {"-fno-delayed-template-parsing"});
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.y.z = 10"));
 }
 
 TEST(ExprMutationAnalyzerTest, NestedMemberNotModified) {
-  auto AST = tooling::buildASTFromCode(
-      "void f() { struct A { int vi; }; struct B { A va; }; "
+  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; }",
+  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;"
+  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;"
+  AST = buildASTFromCode("typedef int& IntRef;"
                          "void f() { int x; static_cast<IntRef>(x) = 10; }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("static_cast<IntRef>(x) = 10"));
 }
 
 TEST(ExprMutationAnalyzerTest, CastToRefNotModified) {
   const auto AST =
-      tooling::buildASTFromCode("void f() { int x; static_cast<int&>(x); }");
+      buildASTFromCode("void f() { int x; static_cast<int&>(x); }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, CastToConstRef) {
-  auto AST = tooling::buildASTFromCode(
-      "void f() { int x; static_cast<const int&>(x); }");
+  auto AST =
+      buildASTFromCode("void f() { int x; static_cast<const int&>(x); }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST =
-      tooling::buildASTFromCode("typedef const int& CIntRef;"
-                                "void f() { int x; static_cast<CIntRef>(x); }");
+  AST = buildASTFromCode("typedef const int& CIntRef;"
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, LambdaDefaultCaptureByValue) {
-  const auto AST =
-      tooling::buildASTFromCode("void f() { int x; [=]() { x = 10; }; }");
+  const auto AST = buildASTFromCode("void f() { int x; [=]() { x; }; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, LambdaExplicitCaptureByValue) {
-  const auto AST =
-      tooling::buildASTFromCode("void f() { int x; [x]() { x = 10; }; }");
+  const auto AST = buildASTFromCode("void f() { int x; [x]() { x; }; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, LambdaDefaultCaptureByRef) {
-  const auto AST =
-      tooling::buildASTFromCode("void f() { int x; [&]() { x = 10; }; }");
+  const auto AST = buildASTFromCode("void f() { int x; [&]() { x = 10; }; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre(ResultOf(removeSpace, "[&](){x=10;}")));
 }
 
 TEST(ExprMutationAnalyzerTest, LambdaExplicitCaptureByRef) {
-  const auto AST =
-      tooling::buildASTFromCode("void f() { int x; [&x]() { x = 10; }; }");
+  const auto AST = buildASTFromCode("void f() { int x; [&x]() { x = 10; }; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre(ResultOf(removeSpace, "[&x](){x=10;}")));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForArrayByRefModified) {
-  auto AST = tooling::buildASTFromCode(
-      "void f() { int x[2]; for (int& e : x) e = 10; }");
+  auto AST =
+      buildASTFromCode("void f() { int x[2]; for (int& e : x) e = 10; }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));
 
-  AST = tooling::buildASTFromCode(
-      "typedef int& IntRef;"
+  AST = buildASTFromCode("typedef int& IntRef;"
                          "void f() { int x[2]; for (IntRef e : x) e = 10; }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForArrayByRefNotModified) {
   const auto AST =
-      tooling::buildASTFromCode("void f() { int x[2]; for (int& e : x) e; }");
+      buildASTFromCode("void f() { int x[2]; for (int& e : x) e; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForArrayByValue) {
-  auto AST = tooling::buildASTFromCode(
-      "void f() { int x[2]; for (int e : x) e = 10; }");
+  auto AST = buildASTFromCode("void f() { int x[2]; for (int e : x) e = 10; }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(
-      "void f() { int* x[2]; for (int* e : x) e = nullptr; }");
+  AST =
+      buildASTFromCode("void f() { int* x[2]; for (int* e : x) e = nullptr; }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(
+  AST = buildASTFromCode(
       "typedef int* IntPtr;"
       "void f() { int* x[2]; for (IntPtr e : x) e = nullptr; }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForArrayByConstRef) {
-  auto AST = tooling::buildASTFromCode(
-      "void f() { int x[2]; for (const int& e : x) e; }");
+  auto AST =
+      buildASTFromCode("void f() { int x[2]; for (const int& e : x) e; }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(
-      "typedef const int& CIntRef;"
+  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(); };"
   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(); };"
+  const auto AST = buildASTFromCode("struct V { int* begin(); int* end(); };"
                                     "void f() { V x; for (int& e : x) e; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForNonArrayByValue) {
-  const auto AST = tooling::buildASTFromCode(
+  const auto AST = buildASTFromCode(
       "struct V { const int* begin() const; const int* end() const; };"
       "void f() { V x; for (int e : x) e; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForNonArrayByConstRef) {
-  const auto AST = tooling::buildASTFromCode(
+  const auto AST = buildASTFromCode(
       "struct V { const int* begin() const; const int* end() const; };"
       "void f() { V x; for (const int& e : x) e; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, UnevaluatedExpressions) {
-  auto AST = tooling::buildASTFromCode(
-      "void f() { int x, y; decltype(x = 10) z = y; }");
+  auto AST = buildASTFromCode("void f() { int x, y; decltype(x = 10) z = y; }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(
-      "void f() { int x, y; __typeof(x = 10) z = y; }");
+  AST = buildASTFromCode("void f() { int x, y; __typeof(x = 10) z = y; }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(
-      "void f() { int x, y; __typeof__(x = 10) z = y; }");
+  AST = buildASTFromCode("void f() { int x, y; __typeof__(x = 10) z = y; }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode("void f() { int x; sizeof(x = 10); }");
+  AST = buildASTFromCode("void f() { int x; sizeof(x = 10); }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode("void f() { int x; alignof(x = 10); }");
+  AST = buildASTFromCode("void f() { int x; alignof(x = 10); }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode("void f() { int x; noexcept(x = 10); }");
+  AST = buildASTFromCode("void f() { int x; noexcept(x = 10); }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCodeWithArgs("namespace std { class type_info; }"
-                                          "void f() { int x; typeid(x = 10); }",
-                                          {"-frtti"});
+  AST = buildASTFromCodeWithArgs("namespace std { class type_info; }"
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(
+  AST = buildASTFromCode(
       "void f() { int x; _Generic(x = 10, int: 0, default: 1); }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, NotUnevaluatedExpressions) {
-  auto AST = tooling::buildASTFromCode("void f() { int x; sizeof(int[x++]); }");
+  auto AST = buildASTFromCode("void f() { int x; sizeof(int[x++]); }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x++"));
 
-  AST = tooling::buildASTFromCodeWithArgs(
+  AST = buildASTFromCodeWithArgs(
       "namespace std { class type_info; }"
       "struct A { virtual ~A(); }; struct B : A {};"
       "struct X { A& f(); }; void f() { X x; typeid(x.f()); }",
       {"-frtti"});
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.f()"));
 }
 
 TEST(ExprMutationAnalyzerTest, UniquePtr) {
   const std::string UniquePtrDef =
       "template <class T> struct UniquePtr {"
       "  UniquePtr();"
       "  UniquePtr(const UniquePtr&) = delete;"
       "  UniquePtr(UniquePtr&&);"
       "  UniquePtr& operator=(const UniquePtr&) = delete;"
       "  UniquePtr& operator=(UniquePtr&&);"
       "  T& operator*() const;"
       "  T* operator->() const;"
       "};";
 
-  auto AST = tooling::buildASTFromCode(
-      UniquePtrDef + "void f() { UniquePtr<int> x; *x = 10; }");
+  auto AST = buildASTFromCode(UniquePtrDef +
+                              "void f() { UniquePtr<int> x; *x = 10; }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("* x = 10"));
 
-  AST = tooling::buildASTFromCode(UniquePtrDef +
-                                  "void f() { UniquePtr<int> x; *x; }");
+  AST = buildASTFromCode(UniquePtrDef + "void f() { UniquePtr<int> x; *x; }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(UniquePtrDef +
-                                  "void f() { UniquePtr<const int> x; *x; }");
+  AST = buildASTFromCode(UniquePtrDef +
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(UniquePtrDef +
-                                  "struct S { int v; };"
+  AST = buildASTFromCode(UniquePtrDef + "struct S { int v; };"
                                         "void f() { UniquePtr<S> x; x->v; }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
 
-  AST = tooling::buildASTFromCode(UniquePtrDef +
-                                  "struct S { int v; };"
-                                  "void f() { UniquePtr<const S> x; x->v; }");
+  AST = buildASTFromCode(UniquePtrDef +
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCode(UniquePtrDef +
-                                  "struct S { void mf(); };"
+  AST =
+      buildASTFromCode(UniquePtrDef + "struct S { void mf(); };"
                                       "void f() { UniquePtr<S> x; x->mf(); }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
 
-  AST = tooling::buildASTFromCode(
-      UniquePtrDef + "struct S { void mf() const; };"
+  AST = buildASTFromCode(UniquePtrDef +
+                         "struct S { void mf() const; };"
                          "void f() { UniquePtr<const S> x; x->mf(); }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
-  AST = tooling::buildASTFromCodeWithArgs(
+  AST = buildASTFromCodeWithArgs(
       UniquePtrDef + "template <class T> void f() { UniquePtr<T> x; x->mf(); }",
       {"-fno-delayed-template-parsing"});
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x->mf()"));
 }
 
 } // namespace clang