[clang][lex][minimizer] Ensure whitespace between squashed lines

[jansvoboda11]

Summary

The minimizer tries to squash multi-line macro definitions into single line. For that to work, contents of each line need to be separated by a space. Since we always strip leading whitespace on lines of a macro definition, the code currently tries to preserve exactly one space that appeared before the backslash.

This means the following code:

#define FOO(BAR) \
  #BAR           \
  baz

gets minimized into:

#define FOO(BAR) #BAR baz

However, if there are no spaces before the backslash on line 2:

#define FOO(BAR) \
  #BAR\
  baz

no space can be preserved, leading to (most likely) malformed macro definition:

#define FOO(BAR) #BARbaz

This patch makes sure we always put exactly one space at the end of line ending with a backslash.

[arphaman]

LG, thanks!

clang/lib/Lex/DependencyDirectivesSourceMinimizer.cpp

 
 static const char *findLastNonSpace(const char *First, const char *Last) {
   assert(First <= Last);
   while (First != Last && isHorizontalWhitespace(Last[-1]))
     --Last;
   return Last;
 }
 
+static const char *findLastNonSpaceNonBackslash(const char *First,
+                                                const char *Last) {
+  assert(First <= Last);
+  while (First != Last &&
+         (isHorizontalWhitespace(Last[-1]) || Last[-1] == '\\'))
+    --Last;
+  return Last;
+}
+
 static const char *findFirstTrailingSpace(const char *First,
                                           const char *Last) {
   const char *LastNonSpace = findLastNonSpace(First, Last);
   if (Last == LastNonSpace)
     return Last;
   assert(isHorizontalWhitespace(LastNonSpace[0]));
   return LastNonSpace + 1;
 }
while (First != End && !isVerticalWhitespace(*First)) {
     if (Last == End || LastBeforeTrailingSpace == First ||
         LastBeforeTrailingSpace[-1] != '\\') {
       append(First, LastBeforeTrailingSpace);
       First = Last;
       skipNewline(First, End);
       return;
     }
 
-    // Print up to the backslash, backing up over spaces. Preserve at least one
-    // space, as the space matters when tokens are separated by a line
-    // continuation.
-    append(First, findFirstTrailingSpace(
-                      First, LastBeforeTrailingSpace - 1));
+    // Print up to the last character that's not a whitespace or backslash.
+    // Then print exactly one space, which matters when tokens are separated by
+    // a line continuation.
+    append(First, findLastNonSpaceNonBackslash(First, Last));
+    put(' ');
 
     First = Last;
     skipNewline(First, End);
     skipOverSpaces(First, End);
   }
 }
 
 static void skipWhitespace(const char *&First, const char *const End) {

clang/unittests/Lex/DependencyDirectivesSourceMinimizerTest.cpp

)";
   )";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ(
       "#if NEVER_ENABLED\n#define why(fmt,...) \"quote dropped\n#endif\n",
       Out.data());
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest,
+     SupportWhitespaceBeforeLineContinuation) {
+  SmallVector<char, 128> Out;
+
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define FOO(BAR) \\\n"
+                                                    "  #BAR\\\n"
+                                                    "  baz\n",
+                                                    Out));
+  EXPECT_STREQ("#define FOO(BAR) #BAR baz\n", Out.data());
+}
+
+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());
 
   Source = "#define X \"\\ \r\nx\"\nvoid foo() {}";