switch from multiline to blockindent

Author: leijurv

clang/docs/ClangFormatStyleOptions.rst

@@ -3436,17 +3436,23 @@ the configuration (without a prefix: ``Auto``).
 
        template <typename Foo, typename Bar>
 
+       template <typename Foo,
+                 typename Bar>
+
        template <
            typename Foo,
            typename Bar>
 
-  * ``BBTCS_Multiline`` (in configuration: ``Multiline``)
-    Break before a template closer if the template spans more than one line.
+  * ``BBTCS_BlockIndent`` (in configuration: ``BlockIndent``)
+    Break before a template closer if the template has broken into block indent style.
 
     .. code-block:: c++
 
        template <typename Foo, typename Bar>
 
+       template <typename Foo,
+                 typename Bar>
+
        template <
            typename Foo,
            typename Bar

clang/include/clang/Format/Format.h

@@ -2258,21 +2258,28 @@ struct FormatStyle {
     /// \code
     ///    template <typename Foo, typename Bar>
     ///
+    ///    template <typename Foo,
+    ///              typename Bar>
+    ///
     ///    template <
     ///        typename Foo,
     ///        typename Bar>
     /// \endcode
     BBTCS_Never,
-    /// Break before a template closer if the template spans more than one line.
+    /// Break before a template closer if the template has broken into block
+    /// indent style.
     /// \code
     ///    template <typename Foo, typename Bar>
     ///
+    ///    template <typename Foo,
+    ///              typename Bar>
+    ///
     ///    template <
     ///        typename Foo,
     ///        typename Bar
     ///    >
     /// \endcode
-    BBTCS_Multiline,
+    BBTCS_BlockIndent,
   };
 
   /// The style of when a line break will be placed before the ``>`` that closes

clang/lib/Format/ContinuationIndenter.cpp

@@ -407,7 +407,7 @@ bool ContinuationIndenter::mustBreak(const LineState &State) {
   if (CurrentState.BreakBeforeClosingParen && Current.is(tok::r_paren))
     return true;
   if (CurrentState.BreakBeforeClosingAngle && Current.is(TT_TemplateCloser) &&
-      Style.BreakBeforeTemplateCloser == FormatStyle::BBTCS_Multiline) {
+      Style.BreakBeforeTemplateCloser == FormatStyle::BBTCS_BlockIndent) {
     return true;
   }
   if (Style.Language == FormatStyle::LK_ObjC &&

clang/lib/Format/Format.cpp

@@ -261,7 +261,7 @@ struct ScalarEnumerationTraits<FormatStyle::BreakBeforeTemplateCloserStyle> {
   static void enumeration(IO &IO,
                           FormatStyle::BreakBeforeTemplateCloserStyle &Value) {
     IO.enumCase(Value, "Never", FormatStyle::BBTCS_Never);
-    IO.enumCase(Value, "Multiline", FormatStyle::BBTCS_Multiline);
+    IO.enumCase(Value, "BlockIndent", FormatStyle::BBTCS_BlockIndent);
   }
 };
 

clang/unittests/Format/ConfigParseTest.cpp

@@ -424,8 +424,8 @@ TEST(ConfigParseTest, ParsesConfiguration) {
               FormatStyle::BOS_All);
 
   Style.BreakBeforeTemplateCloser = FormatStyle::BBTCS_Never;
-  CHECK_PARSE("BreakBeforeTemplateCloser: Multiline", BreakBeforeTemplateCloser,
-              FormatStyle::BBTCS_Multiline);
+  CHECK_PARSE("BreakBeforeTemplateCloser: BlockIndent",
+              BreakBeforeTemplateCloser, FormatStyle::BBTCS_BlockIndent);
   CHECK_PARSE("BreakBeforeTemplateCloser: Never", BreakBeforeTemplateCloser,
               FormatStyle::BBTCS_Never);
 

clang/unittests/Format/FormatTest.cpp

@@ -11134,7 +11134,7 @@ TEST_F(FormatTest, BreakBeforeTemplateCloser) {
                "void foo() {}",
                Style);
 
-  Style.BreakBeforeTemplateCloser = FormatStyle::BBTCS_Multiline;
+  Style.BreakBeforeTemplateCloser = FormatStyle::BBTCS_BlockIndent;
   // BreakBeforeTemplateCloser should NOT force template declarations onto
   // multiple lines.
   verifyFormat("template <typename Foo>\n"
@@ -11156,6 +11156,10 @@ TEST_F(FormatTest, BreakBeforeTemplateCloser) {
                  ">\n"
                  "void foo() {}",
                  Style);
+  verifyNoChange("template <typename Foo,\n"
+                 "          typename Bar>\n"
+                 "void foo() {}",
+                 Style);
   // It should add a line break before > if not already present:
   verifyFormat("template <\n"
                "    typename Foo\n"
@@ -11285,19 +11289,31 @@ TEST_F(FormatTest, BreakBeforeTemplateCloser) {
                ">\n"
                "void foo() {}",
                Style);
-  // But not when the name is looong:
+  // But not when the name is looong. Note that these names are exactly 1
+  // character too long for the ColumnLimit.
   verifyFormat("template <\n"
                "    typename Foo,\n"
-               "    typename Barrrrrrrrrrrrrrrrrrrrrrrrrr\n"
+               "    typename Barrrrrrrrrrrrrrrrrrrr\n"
                ">\n"
                "void foo() {}",
                Style);
+  // Note that this "Foo" is 1 character shorter than the previous "Bar" because
+  // of the comma.
   verifyFormat("template <\n"
-               "    typename Fooooooooooooooooooooooooooo,\n"
+               "    typename Foooooooooooooooooooo,\n"
                "    typename Bar\n"
                ">\n"
                "void foo() {}",
                Style);
+  // BlockIndent style is used when the ColumnLimit allows it:
+  verifyFormat("template <typename Foo,\n"
+               "          typename Barrrrrrrrrrrrrrrrrr>\n"
+               "void foo() {}",
+               Style);
+  verifyFormat("template <typename Fooooooooooooooooooo,\n"
+               "          typename Bar>\n"
+               "void foo() {}",
+               Style);
   // Additionally, long names should be split in one step:
   verifyFormat(
       "template <\n"
@@ -11346,17 +11362,32 @@ TEST_F(FormatTest, BreakBeforeTemplateCloser) {
       "      []<typename T,\n"
       "         typename Loooooooooooooooooooooooooooooooooong\n"
       "      >(T t) {};\n"
+      // Because this is not BlockIndent style, and the [] is empty,
+      // and the "T" is short, then the ">" is placed on the same line.
+      "  auto lambda =\n"
+      "      []<typename Loooooooooooooooooooooooooooooooooong,\n"
+      "         typename T>(T t) {};\n"
       // Nested:
       "  auto lambda =\n"
       "      []<template <typename, typename>\n"
       "         typename Looooooooooooooooooong\n"
       "      >(T t) {};\n"
-      // Nested with long capture:
+      // Same idea, the "T" is now short rather than Looong:
+      "  auto lambda =\n"
+      "      []<template <typename, typename>\n"
+      "         typename T>(T t) {};\n"
+      // Nested with long capture forces the style to block indent:
       "  auto lambda =\n"
       "      [loooooooooooooooooooong]<\n"
       "          template <typename, typename>\n"
       "          typename Looooooooooooooooooong\n"
       "      >(T t) {};\n"
+      // But *now* it stays block indented even when T is short:
+      "  auto lambda =\n"
+      "      [loooooooooooooooooooong]<\n"
+      "          template <typename, typename>\n"
+      "          typename T\n"
+      "      >(T t) {};\n"
       // Nested, with long name and long captures:
       "  auto lambda =\n"
       "      [loooooooooooooooooooong]<\n"
@@ -11366,6 +11397,13 @@ TEST_F(FormatTest, BreakBeforeTemplateCloser) {
       "          >\n"
       "          typename T\n"
       "      >(T t) {};\n"
+      // Allow the nested template to be on the same line:
+      "  auto lambda =\n"
+      "      [loooooooooooooooooooong]<\n"
+      "          template <typename Fooooooooo,\n"
+      "                    typename>\n"
+      "          typename T\n"
+      "      >(T t) {};\n"
       "}",
       Style);
   // Test that if the type is NOT long, it pulls it back into one line:
@@ -11387,6 +11425,12 @@ TEST_F(FormatTest, BreakBeforeTemplateCloser) {
                "  >();\n"
                "}",
                Style);
+  // But if the type is short, we don't need block indent style:
+  verifyFormat("void foo() {\n"
+               "  myFunc<Foo, Foo, Foo, Foo, Foo, Foo,\n"
+               "         Foo, Foo>();\n"
+               "}",
+               Style);
 }
 
 TEST_F(FormatTest, WrapsTemplateParameters) {