diff --git a/clang/unittests/Lex/DependencyDirectivesSourceMinimizerTest.cpp b/clang/unittests/Lex/DependencyDirectivesSourceMinimizerTest.cpp
--- a/clang/unittests/Lex/DependencyDirectivesSourceMinimizerTest.cpp
+++ b/clang/unittests/Lex/DependencyDirectivesSourceMinimizerTest.cpp
@@ -30,13 +30,14 @@
   SmallVector<char, 128> Out;
   SmallVector<Token, 4> Tokens;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("", Out, Tokens));
+  StringRef Source = "";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Tokens));
   EXPECT_TRUE(Out.empty());
   ASSERT_EQ(1u, Tokens.size());
   ASSERT_EQ(pp_eof, Tokens.back().K);
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("abc def\nxyz", Out, Tokens));
+  Source = "abc def\nxyz";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Tokens));
   EXPECT_TRUE(Out.empty());
   ASSERT_EQ(1u, Tokens.size());
   ASSERT_EQ(pp_eof, Tokens.back().K);
@@ -92,8 +93,8 @@
   SmallVector<char, 128> Out;
   SmallVector<Token, 4> Tokens;
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define MACRO", Out, Tokens));
+  StringRef Source = "#define MACRO";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Tokens));
   EXPECT_STREQ("#define MACRO", Out.data());
   ASSERT_EQ(2u, Tokens.size());
   ASSERT_EQ(pp_define, Tokens.front().K);
@@ -102,95 +103,96 @@
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineSpacing) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define MACRO\n\n\n", Out));
+  StringRef Source = "#define MACRO\n\n\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO\n", Out.data());
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define MACRO \n\n\n", Out));
+  Source = "#define MACRO \n\n\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO\n", Out.data());
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define MACRO a \n\n\n", Out));
+  Source = "#define MACRO a \n\n\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO a\n", Out.data());
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define   MACRO\n\n\n", Out));
+  Source = "#define   MACRO\n\n\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO\n", Out.data());
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineMacroArguments) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO()", Out));
+  StringRef Source = "#define MACRO()";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO()", Out.data());
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define MACRO(a, b...)", Out));
+  Source = "#define MACRO(a, b...)";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO(a,b...)\n", Out.data());
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define MACRO content", Out));
+  Source = "#define MACRO content";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO content", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(
-      "#define MACRO   con  tent   ", Out));
+  Source = "#define MACRO   con  tent   ";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO con  tent\n", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(
-      "#define MACRO()   con  tent   ", Out));
+  Source = "#define MACRO()   con  tent   ";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO() con  tent\n", Out.data());
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineInvalidMacroArguments) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO((a))", Out));
+  StringRef Source = "#define MACRO((a))";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO\n", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO(", Out));
+  Source = "#define MACRO(";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO\n", Out.data());
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define MACRO(a * b)", Out));
+  Source = "#define MACRO(a * b)";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO\n", Out.data());
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineHorizontalWhitespace) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(
-      "#define MACRO(\t)\tcon \t tent\t", Out));
+  StringRef Source = "#define MACRO(\t)\tcon \t tent\t";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO() con \t tent\n", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(
-      "#define MACRO(\f)\fcon \f tent\f", Out));
+  Source = "#define MACRO(\f)\fcon \f tent\f";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO() con \f tent\n", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(
-      "#define MACRO(\v)\vcon \v tent\v", Out));
+  Source = "#define MACRO(\v)\vcon \v tent\v";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO() con \v tent\n", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(
-      "#define MACRO \t\v\f\v\t con\f\t\vtent\v\f \v", Out));
+  Source = "#define MACRO \t\v\f\v\t con\f\t\vtent\v\f \v";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO con\f\t\vtent\n", Out.data());
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineMultilineArgs) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define MACRO(a        \\\n"
-                                           "              )",
-                                           Out));
+  StringRef Source = "#define MACRO(a        \\\n"
+                     "              )";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO(a)\n", Out.data());
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define MACRO(a,       \\\n"
-                                           "              b)       \\\n"
-                                           "        call((a),      \\\n"
-                                           "             (b))",
-                                           Out));
+  Source = "#define MACRO(a,       \\\n"
+           "              b)       \\\n"
+           "        call((a),      \\\n"
+           "             (b))";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data());
 }
 
@@ -198,22 +200,21 @@
      DefineMultilineArgsCarriageReturn) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define MACRO(a,       \\\r"
-                                           "              b)       \\\r"
-                                           "        call((a),      \\\r"
-                                           "             (b))",
-                                           Out));
+  StringRef Source = "#define MACRO(a,       \\\r"
+                     "              b)       \\\r"
+                     "        call((a),      \\\r"
+                     "             (b))";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data());
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineMultilineArgsStringize) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO(a,b) \\\n"
-                                                    "                #a \\\n"
-                                                    "                #b",
-                                                    Out));
+  StringRef Source = "#define MACRO(a,b) \\\n"
+                     "                #a \\\n"
+                     "                #b";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO(a,b) #a #b\n", Out.data());
 }
 
@@ -221,12 +222,11 @@
      DefineMultilineArgsCarriageReturnNewline) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define MACRO(a,       \\\r\n"
-                                           "              b)       \\\r\n"
-                                           "        call((a),      \\\r\n"
-                                           "             (b))",
-                                           Out));
+  StringRef Source = "#define MACRO(a,       \\\r\n"
+                     "              b)       \\\r\n"
+                     "        call((a),      \\\r\n"
+                     "             (b))";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data());
 }
 
@@ -234,50 +234,51 @@
      DefineMultilineArgsNewlineCarriageReturn) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define MACRO(a,       \\\n\r"
-                                           "              b)       \\\n\r"
-                                           "        call((a),      \\\n\r"
-                                           "             (b))",
-                                           Out));
+  StringRef Source = "#define MACRO(a,       \\\n\r"
+                     "              b)       \\\n\r"
+                     "        call((a),      \\\n\r"
+                     "             (b))";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data());
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineNumber) {
   SmallVector<char, 128> Out;
 
-  ASSERT_TRUE(minimizeSourceToDependencyDirectives("#define 0\n", Out));
+  StringRef Source = "#define 0\n";
+  ASSERT_TRUE(minimizeSourceToDependencyDirectives(Source, Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineNoName) {
   SmallVector<char, 128> Out;
 
-  ASSERT_TRUE(minimizeSourceToDependencyDirectives("#define &\n", Out));
+  StringRef Source = "#define &\n";
+  ASSERT_TRUE(minimizeSourceToDependencyDirectives(Source, Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineNoWhitespace) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define AND&\n", Out));
+  StringRef Source = "#define AND&\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define AND&\n", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define AND\\\n"
-                                                    "&\n",
-                                                    Out));
+  Source = "#define AND\\\n"
+           "&\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define AND &\n", Out.data());
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, MultilineComment) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define MACRO a/*\n"
-                                           "  /*\n"
-                                           "#define MISSING abc\n"
-                                           "  /*\n"
-                                           "  /* something */ \n"
-                                           "#include  /* \"def\" */ <abc> \n",
-                                           Out));
+  StringRef Source = "#define MACRO a/*\n"
+                     "  /*\n"
+                     "#define MISSING abc\n"
+                     "  /*\n"
+                     "  /* something */ \n"
+                     "#include  /* \"def\" */ <abc> \n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO a\n"
                "#include <abc>\n",
                Out.data());
@@ -286,9 +287,9 @@
 TEST(MinimizeSourceToDependencyDirectivesTest, MultilineCommentInStrings) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO1 \"/*\"\n"
-                                                    "#define MACRO2 \"*/\"\n",
-                                                    Out));
+  StringRef Source = "#define MACRO1 \"/*\"\n"
+                     "#define MACRO2 \"*/\"\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define MACRO1 \"/*\"\n"
                "#define MACRO2 \"*/\"\n",
                Out.data());
@@ -297,25 +298,25 @@
 TEST(MinimizeSourceToDependencyDirectivesTest, Ifdef) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n"
-                                                    "#define B\n"
-                                                    "#endif\n",
-                                                    Out));
+  StringRef Source = "#ifdef A\n"
+                     "#define B\n"
+                     "#endif\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#ifdef A\n"
                "#define B\n"
                "#endif\n",
                Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n"
-                                                    "#define B\n"
-                                                    "#elif B\n"
-                                                    "#define C\n"
-                                                    "#elif C\n"
-                                                    "#define D\n"
-                                                    "#else\n"
-                                                    "#define E\n"
-                                                    "#endif\n",
-                                                    Out));
+  Source = "#ifdef A\n"
+           "#define B\n"
+           "#elif B\n"
+           "#define C\n"
+           "#elif C\n"
+           "#define D\n"
+           "#else\n"
+           "#define E\n"
+           "#endif\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#ifdef A\n"
                "#define B\n"
                "#elif B\n"
@@ -331,12 +332,12 @@
 TEST(MinimizeSourceToDependencyDirectivesTest, Elifdef) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n"
-                                                    "#define B\n"
-                                                    "#elifdef C\n"
-                                                    "#define D\n"
-                                                    "#endif\n",
-                                                    Out));
+  StringRef Source = "#ifdef A\n"
+                     "#define B\n"
+                     "#elifdef C\n"
+                     "#define D\n"
+                     "#endif\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#ifdef A\n"
                "#define B\n"
                "#elifdef C\n"
@@ -344,16 +345,16 @@
                "#endif\n",
                Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n"
-                                                    "#define B\n"
-                                                    "#elifdef B\n"
-                                                    "#define C\n"
-                                                    "#elifndef C\n"
-                                                    "#define D\n"
-                                                    "#else\n"
-                                                    "#define E\n"
-                                                    "#endif\n",
-                                                    Out));
+  Source = "#ifdef A\n"
+           "#define B\n"
+           "#elifdef B\n"
+           "#define C\n"
+           "#elifndef C\n"
+           "#define D\n"
+           "#else\n"
+           "#define E\n"
+           "#endif\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#ifdef A\n"
                "#define B\n"
                "#elifdef B\n"
@@ -369,13 +370,13 @@
 TEST(MinimizeSourceToDependencyDirectivesTest, EmptyIfdef) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n"
-                                                    "void skip();\n"
-                                                    "#elif B\n"
-                                                    "#elif C\n"
-                                                    "#else D\n"
-                                                    "#endif\n",
-                                                    Out));
+  StringRef Source = "#ifdef A\n"
+                     "void skip();\n"
+                     "#elif B\n"
+                     "#elif C\n"
+                     "#else D\n"
+                     "#endif\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#ifdef A\n"
                "#elif B\n"
                "#elif C\n"
@@ -386,13 +387,13 @@
 TEST(MinimizeSourceToDependencyDirectivesTest, EmptyElifdef) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n"
-                                                    "void skip();\n"
-                                                    "#elifdef B\n"
-                                                    "#elifndef C\n"
-                                                    "#else D\n"
-                                                    "#endif\n",
-                                                    Out));
+  StringRef Source = "#ifdef A\n"
+                     "void skip();\n"
+                     "#elifdef B\n"
+                     "#elifndef C\n"
+                     "#else D\n"
+                     "#endif\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#ifdef A\n"
                "#elifdef B\n"
                "#elifndef C\n"
@@ -403,108 +404,117 @@
 TEST(MinimizeSourceToDependencyDirectivesTest, Pragma) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#pragma A\n", Out));
+  StringRef Source = "#pragma A\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#pragma clang\n", Out));
+  Source = "#pragma clang\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("", Out.data());
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#pragma clang module\n", Out));
+  Source = "#pragma clang module\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(
-      "#pragma clang module impor\n", Out));
+  Source = "#pragma clang module impor\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(
-      "#pragma clang module import\n", Out));
+  Source = "#pragma clang module import\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#pragma clang module import\n", Out.data());
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, Include) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#include \"A\"\n", Out));
+  StringRef Source = "#include \"A\"\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#include \"A\"\n", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#include <A>\n", Out));
+  Source = "#include <A>\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#include <A>\n", Out.data());
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#include_next <A>\n", Out));
+  Source = "#include_next <A>\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#include_next <A>\n", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#import <A>\n", Out));
+  Source = "#import <A>\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#import <A>\n", Out.data());
 
-  ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#__include_macros <A>\n", Out));
+  Source = "#__include_macros <A>\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#__include_macros <A>\n", Out.data());
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, AtImport) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("@import A;\n", Out));
+  StringRef Source = "@import A;\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("@import A;\n", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(" @ import  A;\n", Out));
+  Source = " @ import  A;\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("@import A;\n", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("@import A\n;", Out));
+  Source = "@import A\n;";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("@import A;\n", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("@import A.B;\n", Out));
+  Source = "@import A.B;\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("@import A.B;\n", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(
-      "@import /*x*/ A /*x*/ . /*x*/ B /*x*/ \n /*x*/ ; /*x*/", Out));
+  Source = "@import /*x*/ A /*x*/ . /*x*/ B /*x*/ \n /*x*/ ; /*x*/";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("@import A.B;\n", Out.data());
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, AtImportFailures) {
   SmallVector<char, 128> Out;
 
-  ASSERT_TRUE(minimizeSourceToDependencyDirectives("@import A\n", Out));
-  ASSERT_TRUE(minimizeSourceToDependencyDirectives("@import MACRO(A);\n", Out));
-  ASSERT_TRUE(minimizeSourceToDependencyDirectives("@import \" \";\n", Out));
+  StringRef Source = "@import A\n";
+  ASSERT_TRUE(minimizeSourceToDependencyDirectives(Source, Out));
+  Source = "@import MACRO(A);\n";
+  ASSERT_TRUE(minimizeSourceToDependencyDirectives(Source, Out));
+  Source = "@import \" \";\n";
+  ASSERT_TRUE(minimizeSourceToDependencyDirectives(Source, Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, RawStringLiteral) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifndef GUARD\n"
-                                                    "#define GUARD\n"
-                                                    "R\"()\"\n"
-                                                    "#endif\n",
-                                                    Out));
+  StringRef Source = "#ifndef GUARD\n"
+                     "#define GUARD\n"
+                     "R\"()\"\n"
+                     "#endif\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#ifndef GUARD\n"
                "#define GUARD\n"
                "#endif\n",
                Out.data());
 
-  bool RawStringLiteralResult = minimizeSourceToDependencyDirectives(
-      "#ifndef GUARD\n"
-      "#define GUARD\n"
-      R"raw(static constexpr char bytes[] = R"(-?:\,[]{}#&*!|>'"%@`)";)raw"
-      "\n"
-      "#endif\n",
-      Out);
-  ASSERT_FALSE(RawStringLiteralResult);
+  Source = "#ifndef GUARD\n"
+           "#define GUARD\n"
+           R"raw(static constexpr char bytes[] = R"(-?:\,[]{}#&*!|>'"%@`)";)raw"
+           "\n"
+           "#endif\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#ifndef GUARD\n"
                "#define GUARD\n"
                "#endif\n",
                Out.data());
 
-  bool RawStringLiteralResult2 = minimizeSourceToDependencyDirectives(
+  Source =
       "#ifndef GUARD\n"
       "#define GUARD\n"
       R"raw(static constexpr char bytes[] = R"abc(-?:\,[]{}#&*!|>'"%@`)abc";)raw"
       "\n"
-      "#endif\n",
-      Out);
-  ASSERT_FALSE(RawStringLiteralResult2);
+      "#endif\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#ifndef GUARD\n"
                "#define GUARD\n"
                "#endif\n",
@@ -514,29 +524,29 @@
 TEST(MinimizeSourceToDependencyDirectivesTest, SplitIdentifier) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#if\\\n"
-                                                    "ndef GUARD\n"
-                                                    "#define GUARD\n"
-                                                    "#endif\n",
-                                                    Out));
+  StringRef Source = "#if\\\n"
+                     "ndef GUARD\n"
+                     "#define GUARD\n"
+                     "#endif\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#ifndef GUARD\n"
                "#define GUARD\n"
                "#endif\n",
                Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define GUA\\\n"
-                                                    "RD\n",
-                                                    Out));
+  Source = "#define GUA\\\n"
+           "RD\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define GUARD\n", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define GUA\\\r"
-                                                    "RD\n",
-                                                    Out));
+  Source = "#define GUA\\\r"
+           "RD\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define GUARD\n", Out.data());
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define GUA\\\n"
-                                                    "           RD\n",
-                                                    Out));
+  Source = "#define GUA\\\n"
+           "           RD\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define GUA RD\n", Out.data());
 }
 
@@ -544,17 +554,17 @@
      WhitespaceAfterLineContinuationSlash) {
   SmallVector<char, 128> Out;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define A 1 + \\  \n"
-                                                    "2 + \\\t\n"
-                                                    "3\n",
-                                                    Out));
+  StringRef Source = "#define A 1 + \\  \n"
+                     "2 + \\\t\n"
+                     "3\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define A 1 + 2 + 3\n", Out.data());
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, PoundWarningAndError) {
   SmallVector<char, 128> Out;
 
-  for (auto Source : {
+  for (StringRef Source : {
            "#warning '\n#include <t.h>\n",
            "#warning \"\n#include <t.h>\n",
            "#warning /*\n#include <t.h>\n",
@@ -568,7 +578,7 @@
     EXPECT_STREQ("#include <t.h>\n", Out.data());
   }
 
-  for (auto Source : {
+  for (StringRef Source : {
            "#warning \\\n#include <t.h>\n",
            "#error \\\n#include <t.h>\n",
        }) {
@@ -576,7 +586,7 @@
     EXPECT_STREQ("", Out.data());
   }
 
-  for (auto Source : {
+  for (StringRef Source : {
            "#if MACRO\n#warning '\n#endif\n",
            "#if MACRO\n#warning \"\n#endif\n",
            "#if MACRO\n#warning /*\n#endif\n",