[clang][lex] Add minimizer option to pad the output to the input size

[jansvoboda11]

Summary

This patch adds a configuration point to the source minimizer to pad the output to the input size with whitespace. This is useful in D104465.

Depends on D104459.

[dexonsmith]

I'm not sure D104465 (the motivation for this patch) is the right approach, but we can have that discussion over there.

clang/unittests/Lex/DependencyDirectivesSourceMinimizerTest.cpp

24

Why turn this on all the time? That adds a lot of noise below. Can you instead just turn it on for specific targeted tests?

Also, maybe I just missed it, but I don't see any tests that check the behaviour of this flag.

113–115

I'm uncomfortable dropping the check that #define MACRO\n\n\n turns into precisely #define MACRO\n.

[arphaman]

I agree with Duncan, it would be good to avoid modifying the existing test cases if possible

clang/include/clang/Lex/DependencyDirectivesSourceMinimizer.h

 /// \returns false on success, true on error. If the diagnostic engine is not
 /// null, an appropriate error is reported using the given input location
 /// with the offset that corresponds to the minimizer's current buffer offset.
 bool minimizeSourceToDependencyDirectives(
     llvm::StringRef Input, llvm::SmallVectorImpl<char> &Output,
     llvm::SmallVectorImpl<minimize_source_to_dependency_directives::Token>
         &Tokens,
     DiagnosticsEngine *Diags = nullptr,
-    SourceLocation InputSourceLoc = SourceLocation());
+    SourceLocation InputSourceLoc = SourceLocation(),
+    bool PadOutputToInputSize = false);
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_LEX_DEPENDENCY_DIRECTIVES_SOURCE_MINIMIZER_H

clang/lib/Lex/DependencyDirectivesSourceMinimizer.cpp

 struct Minimizer {
   /// Minimized output.
   SmallVectorImpl<char> &Out;
   /// The known tokens encountered during the minimization.
   SmallVectorImpl<Token> &Tokens;
 
   Minimizer(SmallVectorImpl<char> &Out, SmallVectorImpl<Token> &Tokens,
             StringRef Input, DiagnosticsEngine *Diags,
-            SourceLocation InputSourceLoc)
+            SourceLocation InputSourceLoc, bool PadOutputToInputSize)
       : Out(Out), Tokens(Tokens), Input(Input), Diags(Diags),
-        InputSourceLoc(InputSourceLoc) {}
+        InputSourceLoc(InputSourceLoc),
+        PadOutputToInputSize(PadOutputToInputSize) {}
 
   /// Lex the provided source and emit the minimized output.
   ///
   /// \returns True on error.
   bool minimize();
 
 private:
   struct IdInfo {
private:
   /// Reports a diagnostic if the diagnostic engine is provided. Always returns
   /// true at the end.
   bool reportError(const char *CurPtr, unsigned Err);
 
   StringMap<char> SplitIds;
   StringRef Input;
   DiagnosticsEngine *Diags;
   SourceLocation InputSourceLoc;
+  /// Whether the output should be padded to match the size of the input.
+  bool PadOutputToInputSize;
 };
 
 } // end anonymous namespace
 
 bool Minimizer::reportError(const char *CurPtr, unsigned Err) {
   if (!Diags)
     return true;
   assert(CurPtr >= Input.data() && "invalid buffer ptr");
while (First != End)
     if (lexPPLine(First, End))
       return true;
   return false;
 }
 
 bool Minimizer::minimize() {
   bool Error = minimizeImpl(Input.begin(), Input.end());
 
-  assert(Out.size() <= Input.size() && "Output is smaller than input");
+  assert(Out.size() <= Input.size() && "Output is not larger than input");
 
   if (!Error) {
-    // Add a trailing newline if it won't make the output larger than the input.
-    if (!Out.empty() && Out.back() != '\n' && Out.size() < Input.size())
+    // Always try to ensure the contents ends with newline.
+    if (Out.size() < Input.size())
+      if (!Out.empty() && Out.back() != '\n')
         Out.push_back('\n');
+
+    // Pad the output with whitespace if asked to do so.
+    if (PadOutputToInputSize && Out.size() < Input.size()) {
+      Out.insert(Out.end(), Input.size() - Out.size() - 1, ' ');
+      Out.push_back('\n');
+    }
+
     makeToken(pp_eof);
   }
 
   // Null-terminate the output. This way the memory buffer that's passed to
   // Clang will not have to worry about the terminating '\0'.
   Out.push_back(0);
   Out.pop_back();
   return Error;
for (const Token &T : Input) {
     }
     default:
       break;
     }
   }
   return false;
 }
 
-bool clang::minimizeSourceToDependencyDirectives(
-    StringRef Input, SmallVectorImpl<char> &Output,
-    SmallVectorImpl<Token> &Tokens, DiagnosticsEngine *Diags,
-    SourceLocation InputSourceLoc) {
+bool clang::minimizeSourceToDependencyDirectives(StringRef Input,
+                                                 SmallVectorImpl<char> &Output,
+                                                 SmallVectorImpl<Token> &Tokens,
+                                                 DiagnosticsEngine *Diags,
+                                                 SourceLocation InputSourceLoc,
+                                                 bool PadOutputToInputSize) {
   Output.clear();
   Tokens.clear();
-  return Minimizer(Output, Tokens, Input, Diags, InputSourceLoc).minimize();
+  return Minimizer(Output, Tokens, Input, Diags, InputSourceLoc,
+                   PadOutputToInputSize)
+      .minimize();
 }

clang/unittests/Lex/DependencyDirectivesSourceMinimizerTest.cpp

 //===- unittests/Lex/DependencyDirectivesSourceMinimizer.cpp -  -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Lex/DependencyDirectivesSourceMinimizer.h"
 #include "llvm/ADT/SmallString.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace clang;
 using namespace clang::minimize_source_to_dependency_directives;
 
-namespace clang {
+namespace {
+
+bool minimizeSourceToDependencyDirectives(
+    StringRef Input, SmallVectorImpl<char> &Out,
+    SmallVectorImpl<minimize_source_to_dependency_directives::Token> &Tokens) {
+  return minimizeSourceToDependencyDirectives(Input, Out, Tokens, nullptr,
+                                              SourceLocation(),
+                                              /*PadOutputToInputSize=*/true);
+}
 
 bool minimizeSourceToDependencyDirectives(StringRef Input,
                                           SmallVectorImpl<char> &Out) {
   SmallVector<minimize_source_to_dependency_directives::Token, 32> Tokens;
   return minimizeSourceToDependencyDirectives(Input, Out, Tokens);
 }
 
-} // end namespace clang
-
-namespace {
+StringRef rtrim(SmallVectorImpl<char> &Vec) {
+  return StringRef(Vec.data()).rtrim();
+}
 
 TEST(MinimizeSourceToDependencyDirectivesTest, Empty) {
   SmallVector<char, 128> Out;
   SmallVector<Token, 4> Tokens;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("", Out, Tokens));
-  EXPECT_TRUE(Out.empty());
+  EXPECT_EQ("", rtrim(Out));
   ASSERT_EQ(1u, Tokens.size());
   ASSERT_EQ(pp_eof, Tokens.back().K);
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("abc def\nxyz", Out, Tokens));
-  EXPECT_TRUE(Out.empty());
+  EXPECT_EQ("", rtrim(Out));
   ASSERT_EQ(1u, Tokens.size());
   ASSERT_EQ(pp_eof, Tokens.back().K);
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, AllTokens) {
   SmallVector<char, 128> Out;
   SmallVector<Token, 4> Tokens;
 

 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, Define) {
   SmallVector<char, 128> Out;
   SmallVector<Token, 4> Tokens;
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define MACRO", Out, Tokens));
-  EXPECT_STREQ("#define MACRO", Out.data());
+  EXPECT_EQ("#define MACRO", rtrim(Out));
   ASSERT_EQ(2u, Tokens.size());
   ASSERT_EQ(pp_define, Tokens.front().K);
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineSpacing) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define MACRO\n\n\n", Out));
-  EXPECT_STREQ("#define MACRO\n", Out.data());
+  EXPECT_EQ("#define MACRO", rtrim(Out));
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define MACRO \n\n\n", Out));
-  EXPECT_STREQ("#define MACRO\n", Out.data());
+  EXPECT_EQ("#define MACRO", rtrim(Out));
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define MACRO a \n\n\n", Out));
-  EXPECT_STREQ("#define MACRO a\n", Out.data());
+  EXPECT_EQ("#define MACRO a", rtrim(Out));
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define   MACRO\n\n\n", Out));
-  EXPECT_STREQ("#define MACRO\n", Out.data());
+  EXPECT_EQ("#define MACRO", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineMacroArguments) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO()", Out));
-  EXPECT_STREQ("#define MACRO()", Out.data());
+  EXPECT_EQ("#define MACRO()", rtrim(Out));
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define MACRO(a, b...)", Out));
-  EXPECT_STREQ("#define MACRO(a,b...)\n", Out.data());
+  EXPECT_EQ("#define MACRO(a,b...)", rtrim(Out));
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define MACRO content", Out));
-  EXPECT_STREQ("#define MACRO content", Out.data());
+  EXPECT_EQ("#define MACRO content", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(
       "#define MACRO   con  tent   ", Out));
-  EXPECT_STREQ("#define MACRO con  tent\n", Out.data());
+  EXPECT_EQ("#define MACRO con  tent", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(
       "#define MACRO()   con  tent   ", Out));
-  EXPECT_STREQ("#define MACRO() con  tent\n", Out.data());
+  EXPECT_EQ("#define MACRO() con  tent", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineInvalidMacroArguments) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO((a))", Out));
-  EXPECT_STREQ("#define MACRO\n", Out.data());
+  EXPECT_EQ("#define MACRO", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO(", Out));
-  EXPECT_STREQ("#define MACRO\n", Out.data());
+  EXPECT_EQ("#define MACRO", rtrim(Out));
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define MACRO(a * b)", Out));
-  EXPECT_STREQ("#define MACRO\n", Out.data());
+  EXPECT_EQ("#define MACRO", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineHorizontalWhitespace) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(
       "#define MACRO(\t)\tcon \t tent\t", Out));
-  EXPECT_STREQ("#define MACRO() con \t tent\n", Out.data());
+  EXPECT_EQ("#define MACRO() con \t tent", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(
       "#define MACRO(\f)\fcon \f tent\f", Out));
-  EXPECT_STREQ("#define MACRO() con \f tent\n", Out.data());
+  EXPECT_EQ("#define MACRO() con \f tent", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(
       "#define MACRO(\v)\vcon \v tent\v", Out));
-  EXPECT_STREQ("#define MACRO() con \v tent\n", Out.data());
+  EXPECT_EQ("#define MACRO() con \v tent", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(
       "#define MACRO \t\v\f\v\t con\f\t\vtent\v\f \v", Out));
-  EXPECT_STREQ("#define MACRO con\f\t\vtent\n", Out.data());
+  EXPECT_EQ("#define MACRO con\f\t\vtent", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineMultilineArgs) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define MACRO(a        \\\n"
                                            "              )",
                                            Out));
-  EXPECT_STREQ("#define MACRO(a)\n", Out.data());
+  EXPECT_EQ("#define MACRO(a)", rtrim(Out));
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define MACRO(a,       \\\n"
                                            "              b)       \\\n"
                                            "        call((a),      \\\n"
                                            "             (b))",
                                            Out));
-  EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data());
+  EXPECT_EQ("#define MACRO(a,b) call((a), (b))", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest,
      DefineMultilineArgsCarriageReturn) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define MACRO(a,       \\\r"
                                            "              b)       \\\r"
                                            "        call((a),      \\\r"
                                            "             (b))",
                                            Out));
-  EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data());
+  EXPECT_EQ("#define MACRO(a,b) call((a), (b))", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineMultilineArgsStringize) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO(a,b) \\\n"
                                                     "                #a \\\n"
                                                     "                #b",
                                                     Out));
-  EXPECT_STREQ("#define MACRO(a,b) #a #b\n", Out.data());
+  EXPECT_EQ("#define MACRO(a,b) #a #b", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest,
      DefineMultilineArgsCarriageReturnNewline) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define MACRO(a,       \\\r\n"
                                            "              b)       \\\r\n"
                                            "        call((a),      \\\r\n"
                                            "             (b))",
                                            Out));
-  EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data());
+  EXPECT_EQ("#define MACRO(a,b) call((a), (b))", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest,
      DefineMultilineArgsNewlineCarriageReturn) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define MACRO(a,       \\\n\r"
                                            "              b)       \\\n\r"
                                            "        call((a),      \\\n\r"
                                            "             (b))",
                                            Out));
-  EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data());
+  EXPECT_EQ("#define MACRO(a,b) call((a), (b))", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineNumber) {
   SmallVector<char, 128> Out;
 
   ASSERT_TRUE(minimizeSourceToDependencyDirectives("#define 0\n", Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineNoName) {
   SmallVector<char, 128> Out;
 
   ASSERT_TRUE(minimizeSourceToDependencyDirectives("#define &\n", Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineNoWhitespace) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define AND&\n", Out));
-  EXPECT_STREQ("#define AND&\n", Out.data());
+  EXPECT_EQ("#define AND&", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define AND\\\n"
                                                     "&\n",
                                                     Out));
-  EXPECT_STREQ("#define AND &\n", Out.data());
+  EXPECT_EQ("#define AND &", rtrim(Out));
 }
 
 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));
-  EXPECT_STREQ("#define MACRO a\n"
-               "#include <abc>\n",
-               Out.data());
+  EXPECT_EQ("#define MACRO a\n"
+            "#include <abc>",
+            rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, MultilineCommentInStrings) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO1 \"/*\"\n"
                                                     "#define MACRO2 \"*/\"\n",
                                                     Out));
-  EXPECT_STREQ("#define MACRO1 \"/*\"\n"
-               "#define MACRO2 \"*/\"\n",
-               Out.data());
+  EXPECT_EQ("#define MACRO1 \"/*\"\n"
+            "#define MACRO2 \"*/\"",
+            rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, Ifdef) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n"
                                                     "#define B\n"
                                                     "#endif\n",
                                                     Out));
-  EXPECT_STREQ("#ifdef A\n"
-               "#define B\n"
-               "#endif\n",
-               Out.data());
+  EXPECT_EQ("#ifdef A\n"
+            "#endif",
+            rtrim(Out));
 
   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));
-  EXPECT_STREQ("#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.data());
+  EXPECT_EQ("#ifdef A\n"
+            "#endif",
+            rtrim(Out));
 }
 
 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));
-  EXPECT_STREQ("#ifdef A\n"
-               "#define B\n"
-               "#elifdef C\n"
-               "#define D\n"
-               "#endif\n",
-               Out.data());
+  EXPECT_EQ("#ifdef A\n"
+            "#endif",
+            rtrim(Out));
 
   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));
-  EXPECT_STREQ("#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.data());
+  EXPECT_EQ("#ifdef A\n"
+            "#endif",
+            rtrim(Out));
 }
 
 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));
-  EXPECT_STREQ("#ifdef A\n"
-               "#elif B\n"
-               "#elif C\n"
-               "#endif\n",
-               Out.data());
+  EXPECT_EQ("#ifdef A\n"
+            "#endif",
+            rtrim(Out));
 }
 
 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));
-  EXPECT_STREQ("#ifdef A\n"
-               "#elifdef B\n"
-               "#elifndef C\n"
-               "#endif\n",
-               Out.data());
+  EXPECT_EQ("#ifdef A\n"
+            "#endif",
+            rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, Pragma) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#pragma A\n", Out));
-  EXPECT_STREQ("", Out.data());
+  EXPECT_EQ("", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#pragma clang\n", Out));
-  EXPECT_STREQ("", Out.data());
+  EXPECT_EQ("", rtrim(Out));
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#pragma clang module\n", Out));
-  EXPECT_STREQ("", Out.data());
+  EXPECT_EQ("", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(
       "#pragma clang module impor\n", Out));
-  EXPECT_STREQ("", Out.data());
+  EXPECT_EQ("", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(
       "#pragma clang module import\n", Out));
-  EXPECT_STREQ("#pragma clang module import\n", Out.data());
+  EXPECT_EQ("#pragma clang module import", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, Include) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#include \"A\"\n", Out));
-  EXPECT_STREQ("#include \"A\"\n", Out.data());
+  EXPECT_EQ("#include \"A\"", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#include <A>\n", Out));
-  EXPECT_STREQ("#include <A>\n", Out.data());
+  EXPECT_EQ("#include <A>", rtrim(Out));
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#include_next <A>\n", Out));
-  EXPECT_STREQ("#include_next <A>\n", Out.data());
+  EXPECT_EQ("#include_next <A>", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#import <A>\n", Out));
-  EXPECT_STREQ("#import <A>\n", Out.data());
+  EXPECT_EQ("#import <A>", rtrim(Out));
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#__include_macros <A>\n", Out));
-  EXPECT_STREQ("#__include_macros <A>\n", Out.data());
+  EXPECT_EQ("#__include_macros <A>", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, AtImport) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("@import A;\n", Out));
-  EXPECT_STREQ("@import A;\n", Out.data());
+  EXPECT_EQ("@import A;", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(" @ import  A;\n", Out));
-  EXPECT_STREQ("@import A;\n", Out.data());
+  EXPECT_EQ("@import A;", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("@import A\n;", Out));
-  EXPECT_STREQ("@import A;\n", Out.data());
+  EXPECT_EQ("@import A;", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("@import A.B;\n", Out));
-  EXPECT_STREQ("@import A.B;\n", Out.data());
+  EXPECT_EQ("@import A.B;", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(
       "@import /*x*/ A /*x*/ . /*x*/ B /*x*/ \n /*x*/ ; /*x*/", Out));
-  EXPECT_STREQ("@import A.B;\n", Out.data());
+  EXPECT_EQ("@import A.B;", rtrim(Out));
 }
 
 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));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, RawStringLiteral) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifndef GUARD\n"
                                                     "#define GUARD\n"
                                                     "R\"()\"\n"
                                                     "#endif\n",
                                                     Out));
-  EXPECT_STREQ("#ifndef GUARD\n"
-               "#define GUARD\n"
-               "#endif\n",
-               Out.data());
+  EXPECT_EQ("#ifndef GUARD\n"
+            "#endif",
+            rtrim(Out));
 
   bool RawStringLiteralResult = minimizeSourceToDependencyDirectives(
       "#ifndef GUARD\n"
       "#define GUARD\n"
       R"raw(static constexpr char bytes[] = R"(-?:\,[]{}#&*!|>'"%@`)";)raw"
       "\n"
       "#endif\n",
       Out);
   ASSERT_FALSE(RawStringLiteralResult);
-  EXPECT_STREQ("#ifndef GUARD\n"
-               "#define GUARD\n"
-               "#endif\n",
-               Out.data());
+  EXPECT_EQ("#ifndef GUARD\n"
+            "#endif",
+            rtrim(Out));
 
   bool RawStringLiteralResult2 = minimizeSourceToDependencyDirectives(
       "#ifndef GUARD\n"
       "#define GUARD\n"
       R"raw(static constexpr char bytes[] = R"abc(-?:\,[]{}#&*!|>'"%@`)abc";)raw"
       "\n"
       "#endif\n",
       Out);
   ASSERT_FALSE(RawStringLiteralResult2);
-  EXPECT_STREQ("#ifndef GUARD\n"
-               "#define GUARD\n"
-               "#endif\n",
-               Out.data());
+  EXPECT_EQ("#ifndef GUARD\n"
+            "#endif",
+            rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, SplitIdentifier) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#if\\\n"
                                                     "ndef GUARD\n"
                                                     "#define GUARD\n"
                                                     "#endif\n",
                                                     Out));
-  EXPECT_STREQ("#ifndef GUARD\n"
-               "#define GUARD\n"
-               "#endif\n",
-               Out.data());
+  EXPECT_EQ("#ifndef GUARD\n"
+            "#endif",
+            rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define GUA\\\n"
                                                     "RD\n",
                                                     Out));
-  EXPECT_STREQ("#define GUARD\n", Out.data());
+  EXPECT_EQ("#define GUARD", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define GUA\\\r"
                                                     "RD\n",
                                                     Out));
-  EXPECT_STREQ("#define GUARD\n", Out.data());
+  EXPECT_EQ("#define GUARD", rtrim(Out));
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define GUA\\\n"
                                                     "           RD\n",
                                                     Out));
-  EXPECT_STREQ("#define GUA RD\n", Out.data());
+  EXPECT_EQ("#define GUA RD", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest,
      WhitespaceAfterLineContinuationSlash) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define A 1 + \\  \n"
                                                     "2 + \\\t\n"
                                                     "3\n",
                                                     Out));
-  EXPECT_STREQ("#define A 1 + 2 + 3\n", Out.data());
+  EXPECT_EQ("#define A 1 + 2 + 3", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, PoundWarningAndError) {
   SmallVector<char, 128> Out;
 
   for (auto Source : {
            "#warning '\n#include <t.h>\n",
            "#warning \"\n#include <t.h>\n",
            "#warning /*\n#include <t.h>\n",
            "#warning \\\n#include <t.h>\n#include <t.h>\n",
            "#error '\n#include <t.h>\n",
            "#error \"\n#include <t.h>\n",
            "#error /*\n#include <t.h>\n",
            "#error \\\n#include <t.h>\n#include <t.h>\n",
        }) {
     ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
-    EXPECT_STREQ("#include <t.h>\n", Out.data());
+    EXPECT_EQ("#include <t.h>", rtrim(Out));
   }
 
   for (auto Source : {
            "#warning \\\n#include <t.h>\n",
            "#error \\\n#include <t.h>\n",
        }) {
     ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
-    EXPECT_STREQ("", Out.data());
+    EXPECT_EQ("", rtrim(Out));
   }
 
   for (auto Source : {
            "#if MACRO\n#warning '\n#endif\n",
            "#if MACRO\n#warning \"\n#endif\n",
            "#if MACRO\n#warning /*\n#endif\n",
            "#if MACRO\n#error '\n#endif\n",
            "#if MACRO\n#error \"\n#endif\n",
            "#if MACRO\n#error /*\n#endif\n",
        }) {
     ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
-    EXPECT_STREQ("#if MACRO\n#endif\n", Out.data());
+    EXPECT_EQ("#if MACRO\n#endif", rtrim(Out));
   }
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, CharacterLiteral) {
   SmallVector<char, 128> Out;
 
   StringRef Source = R"(
 #include <bob>
 int a = 0'1;
 int b = 0xfa'af'fa;
 int c = 12 ' ';
 #include <foo>
 )";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
-  EXPECT_STREQ("#include <bob>\n#include <foo>\n", Out.data());
+  EXPECT_EQ("#include <bob>\n#include <foo>", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, CharacterLiteralPrefixL) {
   SmallVector<char, 128> Out;
 
   StringRef Source = R"(L'P'
 #if DEBUG
 // '
 #endif
 #include <test.h>
 )";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
-  EXPECT_STREQ("#if DEBUG\n#endif\n#include <test.h>\n", Out.data());
+  EXPECT_EQ("#if DEBUG\n#endif\n#include <test.h>", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, CharacterLiteralPrefixU) {
   SmallVector<char, 128> Out;
 
   StringRef Source = R"(int x = U'P';
 #include <test.h>
 // '
 )";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
-  EXPECT_STREQ("#include <test.h>\n", Out.data());
+  EXPECT_EQ("#include <test.h>", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, CharacterLiteralPrefixu) {
   SmallVector<char, 128> Out;
 
   StringRef Source = R"(int x = u'b';
 int y = u8'a';
 int z = 128'78;
 #include <test.h>
 // '
 )";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
-  EXPECT_STREQ("#include <test.h>\n", Out.data());
+  EXPECT_EQ("#include <test.h>", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, PragmaOnce) {
   SmallVector<char, 128> Out;
   SmallVector<Token, 4> Tokens;
 
   StringRef Source = R"(// comment
 #pragma once
 // another comment
 #include <test.h>
 )";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Tokens));
-  EXPECT_STREQ("#pragma once\n#include <test.h>\n", Out.data());
+  EXPECT_EQ("#pragma once\n#include <test.h>", rtrim(Out));
   ASSERT_EQ(Tokens.size(), 3u);
   EXPECT_EQ(Tokens[0].K,
             minimize_source_to_dependency_directives::pp_pragma_once);
 
   Source = R"(// comment
     #pragma once extra tokens
     // another comment
     #include <test.h>
     )";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
-  EXPECT_STREQ("#pragma once\n#include <test.h>\n", Out.data());
+  EXPECT_EQ("#pragma once\n#include <test.h>", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest,
      SkipLineStringCharLiteralsUntilNewline) {
   SmallVector<char, 128> Out;
 
   StringRef Source = R"(#if NEVER_ENABLED
     #define why(fmt, ...) #error don't try me
     #endif
 
     void foo();
 )";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
-  EXPECT_STREQ(
-      "#if NEVER_ENABLED\n#define why(fmt,...) #error don't try me\n#endif\n",
-      Out.data());
+  EXPECT_EQ(
+      "#if NEVER_ENABLED\n#define why(fmt,...) #error don't try me\n#endif",
+      rtrim(Out));
 
   Source = R"(#if NEVER_ENABLED
       #define why(fmt, ...) "quote dropped
       #endif
 
       void foo();
   )";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
-  EXPECT_STREQ(
-      "#if NEVER_ENABLED\n#define why(fmt,...) \"quote dropped\n#endif\n",
-      Out.data());
+  EXPECT_EQ("#if NEVER_ENABLED\n#define why(fmt,...) \"quote dropped\n#endif",
+            rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest,
      SupportWhitespaceBeforeLineContinuationInStringSkipping) {
   SmallVector<char, 128> Out;
 
   StringRef Source = "#define X '\\ \t\nx'\nvoid foo() {}";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
-  EXPECT_STREQ("#define X '\\ \t\nx'\n", Out.data());
+  EXPECT_EQ("#define X '\\ \t\nx'", rtrim(Out));
 
   Source = "#define X \"\\ \r\nx\"\nvoid foo() {}";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
-  EXPECT_STREQ("#define X \"\\ \r\nx\"\n", Out.data());
+  EXPECT_EQ("#define X \"\\ \r\nx\"", rtrim(Out));
 
   Source = "#define X \"\\ \r\nx\n#include <x>\n";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
-  EXPECT_STREQ("#define X \"\\ \r\nx\n#include <x>\n", Out.data());
+  EXPECT_EQ("#define X \"\\ \r\nx\n#include <x>", rtrim(Out));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, CxxModules) {
   SmallVector<char, 128> Out;
   SmallVector<Token, 4> Tokens;
 
   StringRef Source = R"(
     module;
void h() {
       import a b d e d e f e;
       import foo [[no_unique_address]];
       import foo();
       import f(:sefse);
       import f(->a = 3);
     }
     )";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Tokens));
-  EXPECT_STREQ("#include \"textual-header.h\"\nexport module m;\n"
-               "export import :l [[rename]];\n"
-               "import <<= 3;\nimport a b d e d e f e;\n"
-               "import foo [[no_unique_address]];\nimport foo();\n"
-               "import f(:sefse);\nimport f(->a = 3);\n", Out.data());
+  EXPECT_EQ("#include \"textual-header.h\"\nexport module m;\n"
+            "import f(:sefse);\nimport f(->a = 3);",
+            rtrim(Out));
   ASSERT_EQ(Tokens.size(), 12u);
   EXPECT_EQ(Tokens[0].K,
             minimize_source_to_dependency_directives::pp_include);
   EXPECT_EQ(Tokens[2].K,
             minimize_source_to_dependency_directives::cxx_module_decl);
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, SkippedPPRangesBasic) {