[clang-format] New BreakInheritanceList style AfterComma

[lichray]

Summary

This inheritance list style has been widely adopted by Symantec,
a division of Broadcom Inc. It breaks after the commas that
separate the base-specifiers:

class Derived : public Base1,
                private Base2
{
};

[lichray]

Fix typo in docs.

[lichray]

Simplify implementation.

[MyDeveloperDay]

Adding such a feature like this needs unit tests, it won't be let in without them, you need to add them to clang/unittest/Format/Format.cpp

You also need to update the ReleaseNotes.rst to mention this.

[HazardyKnusperkeks]

clang/include/clang/Format/Format.h

1839

Maybe add a comma, so that the next addition will not need to modify this line?

[lichray]

Add tests and update the release notes.

[lichray]

In D103204#2784234, @MyDeveloperDay wrote:

Adding such a feature like this needs unit tests, it won't be let in without them, you need to add them to clang/unittest/Format/Format.cpp

You also need to update the ReleaseNotes.rst to mention this.

Done.

[lichray]

clang/include/clang/Format/Format.h

1839

Sure.

[lichray]

Correct a copy-pasted test case.

[MyDeveloperDay]

LGTM

[curdeius]

LGTM.

clang/docs/ClangFormatStyleOptions.rst

* ``BILS_AfterColon`` (in configuration: ``AfterColon``)
 
     .. code-block:: c++
 
        class Foo :
            Base1,
            Base2
        {};
 
+  * ``BILS_AfterComma`` (in configuration: ``AfterComma``)
+    Break inheritance list only after and commas.
+
+    .. code-block:: c++
+
+       class Foo : Base1,
+                   Base2
+       {};
+
 
 
 **BreakStringLiterals** (``bool``)
   Allow breaking string literals when formatting.
 
   .. code-block:: c++
 
      true:

clang/include/clang/Format/Format.h

enum BreakInheritanceListStyle : unsigned char {
     BILS_BeforeComma,
     /// Break inheritance list after the colon and commas.
     /// \code
     ///    class Foo :
     ///        Base1,
     ///        Base2
     ///    {};
     /// \endcode
-    BILS_AfterColon
+    BILS_AfterColon,
+    /// Break inheritance list only after the commas.
+    /// \code
+    ///    class Foo : Base1,
+    ///                Base2
+    ///    {};
+    /// \endcode
+    BILS_AfterComma
   };
 
   /// The inheritance list style to use.
   BreakInheritanceListStyle BreakInheritanceList;
 
   /// If ``true``, consecutive namespace declarations will be on the same
   /// line. If ``false``, each namespace is declared on a new line.
   /// \code

clang/lib/Format/Format.cpp

 
 template <>
 struct ScalarEnumerationTraits<FormatStyle::BreakInheritanceListStyle> {
   static void enumeration(IO &IO,
                           FormatStyle::BreakInheritanceListStyle &Value) {
     IO.enumCase(Value, "BeforeColon", FormatStyle::BILS_BeforeColon);
     IO.enumCase(Value, "BeforeComma", FormatStyle::BILS_BeforeComma);
     IO.enumCase(Value, "AfterColon", FormatStyle::BILS_AfterColon);
+    IO.enumCase(Value, "AfterComma", FormatStyle::BILS_AfterComma);
   }
 };
 
 template <>
 struct ScalarEnumerationTraits<FormatStyle::EmptyLineAfterAccessModifierStyle> {
   static void
   enumeration(IO &IO, FormatStyle::EmptyLineAfterAccessModifierStyle &Value) {
     IO.enumCase(Value, "Never", FormatStyle::ELAAMS_Never);

clang/lib/Format/TokenAnnotator.cpp

bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line,
   if (Right.is(TT_CtorInitializerColon) &&
       Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma &&
       !Style.ConstructorInitializerAllOnOneLineOrOnePerLine)
     return true;
   // Break only if we have multiple inheritance.
   if (Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma &&
       Right.is(TT_InheritanceComma))
     return true;
+  if (Style.BreakInheritanceList == FormatStyle::BILS_AfterComma &&
+      Left.is(TT_InheritanceComma))
+    return true;
   if (Right.is(tok::string_literal) && Right.TokenText.startswith("R\""))
     // Multiline raw string literals are special wrt. line breaks. The author
     // has made a deliberate choice and might have aligned the contents of the
     // string literal accordingly. Thus, we try keep existing line breaks.
     return Right.IsMultiline && Right.NewlinesBefore > 0;
   if ((Right.Previous->is(tok::l_brace) ||
        (Right.Previous->is(tok::less) && Right.Previous->Previous &&
         Right.Previous->Previous->is(tok::equal))) &&
bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line,
   if (Right.is(TT_CtorInitializerColon))
     return Style.BreakConstructorInitializers != FormatStyle::BCIS_AfterColon;
   if (Left.is(TT_CtorInitializerComma) &&
       Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma)
     return false;
   if (Right.is(TT_CtorInitializerComma) &&
       Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma)
     return true;
-  if (Left.is(TT_InheritanceComma) &&
-      Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma)
+  if (Left.is(TT_InheritanceComma)) {
+    if (Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma)
       return false;
-  if (Right.is(TT_InheritanceComma) &&
-      Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma)
+    else if (Style.BreakInheritanceList == FormatStyle::BILS_AfterComma)
+      return true;
+  }
+  if (Right.is(TT_InheritanceComma)) {
+    if (Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma)
       return true;
+    else if (Style.BreakInheritanceList == FormatStyle::BILS_AfterComma)
+      return false;
+  }
   if ((Left.is(tok::greater) && Right.is(tok::greater)) ||
       (Left.is(tok::less) && Right.is(tok::less)))
     return false;
   if (Right.is(TT_BinaryOperator) &&
       Style.BreakBeforeBinaryOperators != FormatStyle::BOS_None &&
       (Style.BreakBeforeBinaryOperators == FormatStyle::BOS_All ||
        Right.getPrecedence() != prec::Assignment))
     return true;