[clang-format] Allow all but the first string literal in a sequence to be put on a newline

[krasimir]

Summary

This makes clang-format to consider putting all but first string literals from a sequence on a newline, even if they are in the scope of a chain of a binary operator.
This is needed implicitly, since the string literal breaker may break long string literals into multiple lines, and this patch fixes clang-format to remain idempotent in these cases.

source:

long_long_long_long
    << long_long_long_long << "long lo"
                              "ng"

format before (with 40 columns):

long_long_long_long
    << long_long_long_long
    << "long lo"
       "ng"

format after: same as source.

[krasimir]

• Added a test for a sequence of three string literals

[krasimir]

• Add missing test cases for commas and handling for Objective-C string literals

[krasimir]

• Remove DEBUG statement

[krasimir]

• Reformat newly added chunk of code

[djasper]

As discussed offline, I think this solves the wrong problem. My guess is that breakProtrudingToken checks State.Stack.back().NoLinebreak, but I forget to make it also check NoLinebreakInOperand.

[krasimir]

This patch is superseded by D30575.

lib/Format/ContinuationIndenter.cpp

bool ContinuationIndenter::canBreak(const LineState &State) {
   // Don't break after very short return types (e.g. "void") as that is often
   // unexpected.
   if (Current.is(TT_FunctionDeclarationName) && State.Column < 6) {
     if (Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None)
       return false;
   }
 
   // If binary operators are moved to the next line (including commas for some
-  // styles of constructor initializers), that's always ok.
-  if (!Current.isOneOf(TT_BinaryOperator, tok::comma) &&
+  // styles of constructor initializers), that's always ok. Also the second
+  // element in a sequence of two consecutive string literals is ok to be
+  // moved to the next line.
+  bool ContinuesStringLiteral = Current.isStringLiteral() && Previous.isStringLiteral();
+  if (!ContinuesStringLiteral) {
+    // In case of ObjC string literals, the following code:
+    // @"line1"
+    // @"line2"
+    // turns into the sequence of tokens:
+    // (@, TT_ObjCLiteral),
+    // ("line1", TT_Unknown),
+    // (@, TT_ObjCLiteral),
+    // ("line2", TT_Unknown),
+    // so we need to specially check for that.
+    ContinuesStringLiteral = Current.is(TT_ObjCStringLiteral) &&
+        Previous.is(TT_Unknown) &&
+        Previous.Previous &&
+        Previous.Previous->is(TT_ObjCStringLiteral);
+  }
+  if (!(Current.isOneOf(TT_BinaryOperator, tok::comma) ||
+        ContinuesStringLiteral) &&
       State.Stack.back().NoLineBreakInOperand)
     return false;
 
   return !State.Stack.back().NoLineBreak;
 }
 
 bool ContinuationIndenter::mustBreak(const LineState &State) {
   const FormatToken &Current = *State.NextToken;

unittests/Format/FormatTest.cpp

TEST_F(FormatTest, BreaksStringLiterals) {
 
   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
   AlignLeft.AlignEscapedNewlinesLeft = true;
   EXPECT_EQ("#define A \\\n"
             "  \"some \" \\\n"
             "  \"text \" \\\n"
             "  \"other\";",
             format("#define A \"some text other\";", AlignLeft));
+
+  // The second of two consecutive string literals can be put on a newline.
+  EXPECT_EQ("long_long_long_long\n"
+            "    << long_long_long_long << \"long lo\"\n"
+            "                              \"ng\"",
+            format("long_long_long_long\n"
+                   "    << long_long_long_long << \"long lo\"\n"
+                   "                              \"ng\"",
+                   getLLVMStyleWithColumns(40)));
+  EXPECT_EQ("long_long_long_long(long_lon, \"long lo\"\n"
+            "                              \"ng\");",
+            format("long_long_long_long(long_lon, \"long lo\"\n"
+                   "                              \"ng\");"));
+  // The second and third of three consecutive string literals can be put on a
+  // newline.
+  EXPECT_EQ("long_long_long_long\n"
+            "    << long_long_long_long << \"long lo\"\n"
+            "                              \"long lo\"\n"
+            "                              \"long lo\"",
+            format("long_long_long_long\n"
+                   "    << long_long_long_long << \"long lo\"\n"
+                   "                              \"long lo\"\n"
+                   "                              \"long lo\"",
+                   getLLVMStyleWithColumns(40)));
+  EXPECT_EQ("long_long_long_long(long_lon, \"long lo\"\n"
+            "                              \"long lo\"\n"
+            "                              \"ng\");",
+            format("long_long_long_long(long_lon, \"long lo\"\n"
+                   "                              \"long lo\"\n"
+                   "                              \"ng\");"));
+  EXPECT_EQ("long_long_long_long(long_lon, L\"long lo\"\n"
+            "                              U\"long lo\"\n"
+            "                              u8\"ng\");",
+            format("long_long_long_long(long_lon, L\"long lo\"\n"
+                   "                              U\"long lo\"\n"
+                   "                              u8\"ng\");"));
 }
 
 TEST_F(FormatTest, FullyRemoveEmptyLines) {
   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
   NoEmptyLines.MaxEmptyLinesToKeep = 0;
   EXPECT_EQ("int i = a(b());",
             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
 }

unittests/Format/FormatTestObjC.cpp

verifyFormat(
       "};");
 
   Style = getGoogleStyle(FormatStyle::LK_ObjC);
   verifyFormat(
       "@{\n"
       "  NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee : "
       "regularFont,\n"
       "};");
+
+  // The second of two consecutive string literals can be but on a newline.
+  Style = getGoogleStyle(FormatStyle::LK_ObjC);
+  Style.ColumnLimit = 40;
+  EXPECT_EQ("long_long_long_long\n"
+            "    << long_long_long_long << @\"long lo\"\n"
+            "                              @\"ng\"",
+            format("long_long_long_long\n"
+                   "    << long_long_long_long << @\"long lo\"\n"
+                   "                              @\"ng\""));
+  EXPECT_EQ("long_long_long_long(long_lon, @\"long lo\"\n"
+            "                              @\"ng\");",
+            format("long_long_long_long(long_lon, @\"long lo\"\n"
+                   "                              @\"ng\");"));
+  // The second and third of three consecutive string literals can be but on a
+  // newline.
+  Style = getGoogleStyle(FormatStyle::LK_ObjC);
+  Style.ColumnLimit = 40;
+  EXPECT_EQ("long_long_long_long\n"
+            "    << long_long_long_long << @\"long lo\"\n"
+            "                              @\"long lo\"\n"
+            "                              @\"ng\"",
+            format("long_long_long_long\n"
+                   "    << long_long_long_long << @\"long lo\"\n"
+                   "                              @\"long lo\"\n"
+                   "                              @\"ng\""));
+  EXPECT_EQ("long_long_long_long(long_lon, @\"long lo\"\n"
+            "                              @\"long lo\"\n"
+            "                              @\"ng\");",
+            format("long_long_long_long(long_lon, @\"long lo\"\n"
+                   "                              @\"long lo\"\n"
+                   "                              @\"ng\");"));
 }
 
 TEST_F(FormatTestObjC, ObjCArrayLiterals) {
   verifyIncompleteFormat("@[");
   verifyFormat("@[]");
   verifyFormat(
       "NSArray *array = @[ @\" Hey \", NSApp, [NSNumber numberWithInt:42] ];");
   verifyFormat("return @[ @3, @[], @[ @4, @5 ] ];");