Add operator style options to clang-format

[KitsuneAlex]

Summary

First of all, i apologize in advance if anything in the submission proccess was messed up, this is my first time contributing to the LLVM project.

This patch adds a new option 'SpaceAfterOperatorKeyword' to clang-format.
As the name implies, this will insert a space after every operator keyword, effectively splitting off the actual operator from the keyword, which i found is a missing option for my private and professional work.

This patch adds two new options to clang-format;

• SpaceAfterOperatorOverload, which as the name implies will insert a space after the operator keyword in any operator overload declaration.
• SpaceAfterOperatorCall, which will insert a space after the operator keyword within operator call expressions or address-of expressions.

This allows more finely grained control over the placement of the actual operator token which follows the operator keyword.

[KitsuneAlex]

I made a stupid mistake and messed up the formatting of the anonymous parameter in the unit test code.
Fixing this right now, don't know why it slipped through.

[KitsuneAlex]

I removed the redundant anonymous parameter in the unit test source string. Locally all formatting tests passed fine.

[KitsuneAlex]

I took the liberty and extended the unit tests for SpaceAfterTemplateKeyword and SpaceAfterOperator keyword to cover both possible cases, which lead to me discovering that my code was not quite right because of an early-out return path in a calling function.

Everything is fixed and tested now.

[HazardyKnusperkeks]

Can you add a note to the release notes also please?

clang/include/clang/Format/Format.h

3727

O before T, please resort.

clang/lib/Format/Format.cpp

1740

Not needed, it is initially created with LLVMStyle and then only modified.

clang/unittests/Format/FormatTest.cpp

22934

Please also use a test case with a call to an operator.

[KitsuneAlex]

In D152443#4406923, @HazardyKnusperkeks wrote:

Can you add a note to the release notes also please?

Of course! Doing that right now :)

Another thing i was wondering was if it would make sense to add a separate option for deciding whether to insert a space between the operator keyword
specifically in the case of a call expression.

Meaning operator overload definitions would use SpaceAfterOperatorKeyword while operator call expressions would use
something like SpaceAfterOperatorCall maybe. In the case this sounds like a good idea to you, i'd also suggest to have SpaceAfterOperatorCall
use SpaceAfterOperatorKeyword as its default value.

[KitsuneAlex]

Applied all suggested changes and added a suiting option for aformentioned edge-case for call expressions.
Also added the missing release notes to the apropriate section.

[KitsuneAlex]

Some additional changes because i exceeded the maximum line width on multiple occasions.

NOTE: Clang-Format Team Automated Review Comment

Your review contains a change to clang/include/clang/Format/Format.h but does not contain an update to ClangFormatStyleOptions.rst

ClangFormatStyleOptions.rst is generated via clang/docs/tools/dump_format_style.py, please run this to regenerate the .rst

You can validate that the rst is valid by running.

./docs/tools/dump_format_style.py
mkdir -p html
/usr/bin/sphinx-build -n ./docs ./html

[KitsuneAlex]

I had some issues with Git there because i messed up a merge, so the diff was bad. Here's the proper diff.

[KitsuneAlex]

Clean up the formatting with clang-format.

[MyDeveloperDay]

clang/docs/ClangFormatStyleOptions.rst

4709

could we use something like SpaceAfterOperatorDeclaration to differentiate

4719

I'm not going to lie I'm not a fan of SpaceAfterOperatorKeywordInCall as an option name, any other suggestions for a name?

clang/lib/Format/TokenAnnotator.cpp

3762

kind of unrelated change?

clang/unittests/Format/FormatTest.cpp

22916

I assume I could have foo->operator ==();

[MyDeveloperDay]

In D152443#4407438, @KitsuneAlex wrote:

I had some issues with Git there because i messed up a merge, so the diff was bad. Here's the proper diff.

NOTE: Clang-Format Team Automated Review Comment

keeps you honest right!

[HazardyKnusperkeks]

In D152443#4407331, @KitsuneAlex wrote:

Applied all suggested changes and added a suiting option for aformentioned edge-case for call expressions.
Also added the missing release notes to the apropriate section.

Please mark comments as done, if you think they are done.

clang/docs/ClangFormatStyleOptions.rst

4709

But it also applies to the definition?

Keyword seems to be wrong too, if we have a second option for the calls...

I currently have no recommendations for the naming.

clang/lib/Format/TokenAnnotator.cpp

4206

bool Foo::operator==() = default;?

Please add a test. :)

clang/unittests/Format/FormatTest.cpp

22915

Can you add an empty line, so that the 2 blocks are visually separated?

22916

Of course you can. :)

[KitsuneAlex]

In D152443#4408991, @MyDeveloperDay wrote:

In D152443#4407438, @KitsuneAlex wrote:

I had some issues with Git there because i messed up a merge, so the diff was bad. Here's the proper diff.

NOTE: Clang-Format Team Automated Review Comment

keeps you honest right!

Yes, i was referring to the fact that the previous diff was only 30% of my intended changes if you look at the changed files, which was caused by an unsmart local merge on my end.
That's why my following diff corrected the formatting.

[KitsuneAlex]

This revision of the diff changes the names of the new style options to SpaceAfterOperatorOverload and SpaceAfterOperatorCall, which clarifies their scope a lot better i think.
I also rewrote the logic to apply formatting that fits exactly what their name implies respectively,
the new tests i added should cover all common use cases (except i forgot some again).

[HazardyKnusperkeks]

In D152443#4412069, @KitsuneAlex wrote:

This revision of the diff changes the names of the new style options to SpaceAfterOperatorOverload and SpaceAfterOperatorCall, which clarifies their scope a lot better i think.
I also rewrote the logic to apply formatting that fits exactly what their name implies respectively,
the new tests i added should cover all common use cases (except i forgot some again).

Two cases missing: operator==() (Calling within a class), and what happens when taking the address &operator==? (With and without qualification.)

clang/unittests/Format/FormatTest.cpp

22916

Nice to check for that too!

[KitsuneAlex]

Revamped the formatting logic again and added the requested unit tests.

[KitsuneAlex]

Added missing test case for default operator declarations as requested, as well as blank lines between the blocks inside the test functions
as visual separators.

[KitsuneAlex]

Fix broken style in TokenAnnotator.cpp. I don't know how i keep missing these, trying to get better.

[MyDeveloperDay]

did you cover the case where I have a namespaced, static

foo::Bar->operator==()
foo::Bar->m_oper->operator==()
foo::Bar->m_oper.operator==()
foo::Bar.operator==()

clang/lib/Format/TokenAnnotator.cpp

4208–4211

I don't quite understand what case needs this?

[HazardyKnusperkeks]

clang/lib/Format/TokenAnnotator.cpp

4204–4210

4212

Token could be null here already.

4214

This would be operator::, or not?

clang/docs/ClangFormatStyleOptions.rst

 **SpaceAfterLogicalNot** (``Boolean``) :versionbadge:`clang-format 9` :ref:`¶ <SpaceAfterLogicalNot>`
   If ``true``, a space is inserted after the logical not operator (``!``).
 
   .. code-block:: c++
 
      true:                                  false:
      ! someExpression();            vs.     !someExpression();
 
+.. _SpaceAfterOperatorKeyword:
+
+**SpaceAfterOperatorKeyword** (``Boolean``) :versionbadge:`clang-format 17` :ref:`¶ <SpaceAfterOperatorKeyword>`
+  If ``true``, a space will be inserted after the 'operator' keyword.
+
+  .. code-block:: c++
+
+     true:                                  false:
+     bool operator ==(...);         vs.     bool operator==(...);
+
+.. _SpaceAfterOperatorKeywordInCall:
+
+**SpaceAfterOperatorKeywordInCall** (``Boolean``) :versionbadge:`clang-format 17` :ref:`¶ <SpaceAfterOperatorKeywordInCall>`
+  If ``true``, a space will be inserted after the 'operator' keyword in a call expression.
+  This option defaults to SpaceAfterOperatorKeyword.
+
+  .. code-block:: c++
+
+     true:                                  false:
+     foo.operator ==(...);         vs.      foo.operator==(...);
+     foo.Foo::operator ==(...);    vs.      foo.Foo::operator==(...);
+
 .. _SpaceAfterTemplateKeyword:
 
 **SpaceAfterTemplateKeyword** (``Boolean``) :versionbadge:`clang-format 4` :ref:`¶ <SpaceAfterTemplateKeyword>`
   If ``true``, a space will be inserted after the 'template' keyword.
 
   .. code-block:: c++
 
      true:                                  false:

clang/docs/ReleaseNotes.rst

- Add ``NextLineOnly`` style to option ``PackConstructorInitializers``.
   put the initializers on the current line first, instead, it will try to
   put the initializers on the next line only.
 - Add additional Qualifier Ordering support for special cases such
   as templates, requires clauses, long qualified names.
 - Fix all known issues associated with ``LambdaBodyIndentation: OuterScope``.
 - Add ``BracedInitializerIndentWidth`` which can be used to configure
   the indentation level of the contents of braced init lists.
 - Add ``KeepEmptyLinesAtEOF`` to keep empty lines at end of file.
+- Add ``SpaceAfterOperatorKeyword`` style option.
+- Add ``SpaceAfterOperatorKeywordInCall`` style option.
 
 libclang
 --------
 
 - Introduced the new function ``clang_CXXMethod_isExplicit``,
   which identifies whether a constructor or conversion function cursor
   was marked with the explicit identifier.
 

clang/include/clang/Format/Format.h

   /// If ``true``, a space is inserted after the logical not operator (``!``).
   /// \code
   ///    true:                                  false:
   ///    ! someExpression();            vs.     !someExpression();
   /// \endcode
   /// \version 9
   bool SpaceAfterLogicalNot;
 
+  /// If \c true, a space will be inserted after the 'operator' keyword.
+  /// \code
+  ///    true:                                  false:
+  ///    bool operator ==(...);         vs.     bool operator==(...);
+  /// \endcode
+  /// \version 17
+  bool SpaceAfterOperatorKeyword;
+
+  /// If \c true, a space will be inserted after the 'operator' keyword in a call expression.
+  /// This option defaults to SpaceAfterOperatorKeyword.
+  /// \code
+  ///    true:                                  false:
+  ///    foo.operator ==(...);         vs.      foo.operator==(...);
+  ///    foo.Foo::operator ==(...);    vs.      foo.Foo::operator==(...);
+  /// \endcode
+  /// \version 17
+  bool SpaceAfterOperatorKeywordInCall;
+
   /// If \c true, a space will be inserted after the 'template' keyword.
   /// \code
   ///    true:                                  false:
   ///    template <int> void foo();     vs.     template<int> void foo();
   /// \endcode
   /// \version 4
   bool SpaceAfterTemplateKeyword;
 
   /// Different ways to put a space before opening parentheses.
   enum SpaceAroundPointerQualifiersStyle : int8_t {
     /// Don't ensure spaces around pointer qualifiers and use PointerAlignment
     /// instead.
     /// \code
     ///    PointerAlignment: Left                 PointerAlignment: Right
     ///    void* const* x = NULL;         vs.     void *const *x = NULL;
     /// \endcode
     SAPQ_Default,
     /// Ensure that there is a space before pointer qualifiers.
     /// \code
     ///    PointerAlignment: Left                 PointerAlignment: Right
     ///    void* const* x = NULL;         vs.     void * const *x = NULL;
     /// \endcode
     SAPQ_Before,
return AccessModifierOffset == R.AccessModifierOffset &&
            RequiresClausePosition == R.RequiresClausePosition &&
            RequiresExpressionIndentation == R.RequiresExpressionIndentation &&
            SeparateDefinitionBlocks == R.SeparateDefinitionBlocks &&
            ShortNamespaceLines == R.ShortNamespaceLines &&
            SortIncludes == R.SortIncludes &&
            SortJavaStaticImport == R.SortJavaStaticImport &&
            SpaceAfterCStyleCast == R.SpaceAfterCStyleCast &&
            SpaceAfterLogicalNot == R.SpaceAfterLogicalNot &&
+           SpaceAfterOperatorKeyword == R.SpaceAfterOperatorKeyword &&
+           SpaceAfterOperatorKeywordInCall == 
+               R.SpaceAfterOperatorKeywordInCall &&
            SpaceAfterTemplateKeyword == R.SpaceAfterTemplateKeyword &&
            SpaceBeforeAssignmentOperators == R.SpaceBeforeAssignmentOperators &&
            SpaceBeforeCaseColon == R.SpaceBeforeCaseColon &&
            SpaceBeforeCpp11BracedList == R.SpaceBeforeCpp11BracedList &&
            SpaceBeforeCtorInitializerColon ==
                R.SpaceBeforeCtorInitializerColon &&
            SpaceBeforeInheritanceColon == R.SpaceBeforeInheritanceColon &&
            SpaceBeforeJsonColon == R.SpaceBeforeJsonColon &&

clang/lib/Format/Format.cpp

IO.mapOptional("RequiresExpressionIndentation",
                    Style.RequiresExpressionIndentation);
     IO.mapOptional("SeparateDefinitionBlocks", Style.SeparateDefinitionBlocks);
     IO.mapOptional("ShortNamespaceLines", Style.ShortNamespaceLines);
     IO.mapOptional("SortIncludes", Style.SortIncludes);
     IO.mapOptional("SortJavaStaticImport", Style.SortJavaStaticImport);
     IO.mapOptional("SortUsingDeclarations", Style.SortUsingDeclarations);
     IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
     IO.mapOptional("SpaceAfterLogicalNot", Style.SpaceAfterLogicalNot);
+    IO.mapOptional("SpaceAfterOperatorKeyword",
+                   Style.SpaceAfterOperatorKeyword);
+    IO.mapOptional("SpaceAfterOperatorKeywordInCall",
+                   Style.SpaceAfterOperatorKeywordInCall);
     IO.mapOptional("SpaceAfterTemplateKeyword",
                    Style.SpaceAfterTemplateKeyword);
     IO.mapOptional("SpaceAroundPointerQualifiers",
                    Style.SpaceAroundPointerQualifiers);
     IO.mapOptional("SpaceBeforeAssignmentOperators",
                    Style.SpaceBeforeAssignmentOperators);
     IO.mapOptional("SpaceBeforeCaseColon", Style.SpaceBeforeCaseColon);
     IO.mapOptional("SpaceBeforeCpp11BracedList",
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.RequiresExpressionIndentation = FormatStyle::REI_OuterScope;
   LLVMStyle.SeparateDefinitionBlocks = FormatStyle::SDS_Leave;
   LLVMStyle.ShortNamespaceLines = 1;
   LLVMStyle.SortIncludes = FormatStyle::SI_CaseSensitive;
   LLVMStyle.SortJavaStaticImport = FormatStyle::SJSIO_Before;
   LLVMStyle.SortUsingDeclarations = FormatStyle::SUD_LexicographicNumeric;
   LLVMStyle.SpaceAfterCStyleCast = false;
   LLVMStyle.SpaceAfterLogicalNot = false;
+  LLVMStyle.SpaceAfterOperatorKeyword = false;
+  LLVMStyle.SpaceAfterOperatorKeywordInCall = false;
   LLVMStyle.SpaceAfterTemplateKeyword = true;
   LLVMStyle.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Default;
   LLVMStyle.SpaceBeforeCaseColon = false;
   LLVMStyle.SpaceBeforeCtorInitializerColon = true;
   LLVMStyle.SpaceBeforeInheritanceColon = true;
   LLVMStyle.SpaceBeforeJsonColon = false;
   LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
   LLVMStyle.SpaceBeforeParensOptions = {};
FormatStyle getMozillaStyle() {
   MozillaStyle.Cpp11BracedListStyle = false;
   MozillaStyle.FixNamespaceComments = false;
   MozillaStyle.IndentCaseLabels = true;
   MozillaStyle.ObjCSpaceAfterProperty = true;
   MozillaStyle.ObjCSpaceBeforeProtocolList = false;
   MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200;
   MozillaStyle.PointerAlignment = FormatStyle::PAS_Left;
   MozillaStyle.SpaceAfterTemplateKeyword = false;
   return MozillaStyle;
 }
 
 FormatStyle getWebKitStyle() {
   FormatStyle Style = getLLVMStyle();
   Style.AccessModifierOffset = -4;
   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
   Style.AlignOperands = FormatStyle::OAS_DontAlign;
   Style.AlignTrailingComments = {};

clang/lib/Format/TokenAnnotator.cpp

bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
   if (Left.is(tok::kw_auto) && Right.isOneOf(tok::l_paren, tok::l_brace))
     return false;
 
   // operator co_await(x)
   if (Right.is(tok::l_paren) && Left.is(tok::kw_co_await) && Left.Previous &&
       Left.Previous->is(tok::kw_operator)) {
     return false;
   }
+
   // co_await (x), co_yield (x), co_return (x)
   if (Left.isOneOf(tok::kw_co_await, tok::kw_co_yield, tok::kw_co_return) &&
       !Right.isOneOf(tok::semi, tok::r_paren)) {
     return true;
   }
 
   if (Left.is(tok::l_paren) || Right.is(tok::r_paren)) {
     return (Right.is(TT_CastRParen) ||
if (Style.isCpp()) {
     }
     if (Left.is(tok::ellipsis) && Right.is(tok::identifier) &&
         Line.First->is(Keywords.kw_import)) {
       return false;
     }
     // Space in __attribute__((attr)) ::type.
     if (Left.is(TT_AttributeParen) && Right.is(tok::coloncolon))
       return true;
-
-    if (Left.is(tok::kw_operator))
-      return Right.is(tok::coloncolon);
+    if (Left.is(tok::kw_operator)) {
+      if (Left.Previous && 
+          Left.Previous->isOneOf(tok::coloncolon, tok::period))
+        return Style.SpaceAfterOperatorKeywordInCall || 
+               Right.is(tok::coloncolon);
+      return Style.SpaceAfterOperatorKeyword || Right.is(tok::coloncolon);
+    }
     if (Right.is(tok::l_brace) && Right.is(BK_BracedInit) &&
         !Left.opensScope() && Style.SpaceBeforeCpp11BracedList) {
       return true;
     }
     if (Left.is(tok::less) && Left.is(TT_OverloadedOperator) &&
         Right.is(TT_TemplateOpener)) {
       return true;
     }
   } else if (Style.Language == FormatStyle::LK_Proto ||
              Style.Language == FormatStyle::LK_TextProto) {
     if (Right.is(tok::period) &&
         Left.isOneOf(Keywords.kw_optional, Keywords.kw_required,

clang/unittests/Format/ConfigParseTest.cpp

TEST(ConfigParseTest, ParsesConfigurationBools) {
   CHECK_PARSE_BOOL(SpacesInParentheses);
   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
+  CHECK_PARSE_BOOL(SpaceAfterOperatorKeyword);
+  CHECK_PARSE_BOOL(SpaceAfterOperatorKeywordInCall);
   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
   CHECK_PARSE_BOOL(SpaceBeforeCaseColon);
   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
   CHECK_PARSE_BOOL(SpaceBeforeJsonColon);

clang/unittests/Format/FormatTest.cpp

verifyFormat("// clang-format off\n"
                "// clang-format on\n",
                Spaces);
   verifyFormat("// clang-format off\n"
                "foo< < <1, 1> > >();\n"
                "// clang-format on\n",
                Spaces);
 }
 
+TEST_F(FormatTest, SpaceAfterOperatorKeyword) {
+  FormatStyle Style = getLLVMStyle();
+  verifyFormat("bool operator==();", Style);
+  Style.SpaceAfterOperatorKeyword = true;
+  verifyFormat("bool operator ==();", Style);
+}
+
+TEST_F(FormatTest, SpaceAfterOperatorKeywordInCall) {
+  FormatStyle Style = getLLVMStyle();
+  verifyFormat("foo.operator==();", Style);
+  verifyFormat("foo.Foo::operator==();", Style);
+  Style.SpaceAfterOperatorKeywordInCall = true;
+  verifyFormat("foo.operator ==();", Style);
+  verifyFormat("foo.Foo::operator ==();", Style);
+}
+
 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
   FormatStyle Style = getLLVMStyle();
+  verifyFormat("template <int> void foo();", Style);
   Style.SpaceAfterTemplateKeyword = false;
   verifyFormat("template<int> void foo();", Style);
 }
 
 TEST_F(FormatTest, TripleAngleBrackets) {
   verifyFormat("f<<<1, 1>>>();");
   verifyFormat("f<<<1, 1, 1, s>>>();");
   verifyFormat("f<<<a, b, c, d>>>();");
   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
   verifyFormat("f<param><<<1, 1>>>();");
   verifyFormat("f<1><<<1, 1>>>();");
   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                "aaaaaaaaaaa<<<\n    1, 1>>>();");
   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
 }
 
 TEST_F(FormatTest, MergeLessLessAtEnd) {
   verifyFormat("<<");