[clang-format] Fix incorrect alignment of operator= overloads.

[glotchimo]

Summary

Fixes https://github.com/llvm/llvm-project/issues/31568.

Added a check for operator keyword tokens.

[glotchimo]

I don't know why, but clang-format reformatted most if not all of the long/block comments in WhitespaceManager.cpp. Will it be necessary for me to revert the changes to those comments and skip formatting when updating the diff so as to keep it minimal?

[glotchimo]

Same change as before but without the changes to long and block comments.

[curdeius]

Thanks for working on this!
I'll have a closer look tomorrow or on Tuesday.

clang/lib/Format/WhitespaceManager.cpp

738

Maybe getPreviousNonComment? Cf. test comment.

739

Please spell out the type instead of auto.

clang/unittests/Format/FormatTest.cpp

16172

Are other operators impacted too by this bug? Like ==, <=, !=.

16174

What happens if there's a block comment between operator and =?

[glotchimo]

Excellent, thank you! I'll get right on these edits.

[HazardyKnusperkeks]

Thanks for fixing this. It hit my quite some times, but never had the time to look into it.

[glotchimo]

Explicitly declare FormatToken type instead of using auto.

[glotchimo]

Add equality operator tests.

[curdeius]

Could you check if your patch fixes https://github.com/llvm/llvm-project/issues/33044 as well?
If so, please add tests.

[MyDeveloperDay]

In D117421#3246627, @glotchimo wrote:

I don't know why, but clang-format reformatted most if not all of the long/block comments in WhitespaceManager.cpp. Will it be necessary for me to revert the changes to those comments and skip formatting when updating the diff so as to keep it minimal?

If when editing you save (and clang-format) when you've missed a } then the file likely reindented, this, in turn, reflowed the comments, which means when you add the '}' back in, those comments have newlines in different places

once reflowed the comments don't reflow back.

This is commonly how I mess up, I then git difftool with something like winmerge and revert the comments one by one.

[MyDeveloperDay]

clang/unittests/Format/FormatTest.cpp

16172

can you add a test showing what happens when you don't have the { in there definition?

16189

can you mi

[curdeius]

With your patch I still see the bug in this case:

struct S {
  /*comment*/ S(const S &) = default;
  void f()                 = default;
  S &operator              =(S);
};

Mind the operator =.
It happens every time that operator= has only declaration (no definition body).

Another failure:

struct S {
  /*comment*/ S(const S &) = default;
  void f()                 = default;
  S &operator/**/          =(S) {}
};

As mentioned yesterday, comment between operator and =.

Note, /*comment*/ is there just to make the spacing more visible. It's unrelated to the bug otherwise.

[curdeius]

clang/lib/Format/WhitespaceManager.cpp

738

This should fix the operator/**/ = problem.

[curdeius]

clang/lib/Format/WhitespaceManager.cpp

738–745

Can't we simplify this?

741

And this should fix the declaration-only problem.

[glotchimo]

Add overload declaration look-ahead.

[glotchimo]

I was tinkering with the use of getPreviousNonComment last night before signing off and the problem that I noticed was that, though it stops the operator= from being split and aligned with previous lines, it adds a single space:

 /* long long padding */ int() = default;
 int &operator()               = default;
-int &operator/**/=();
+int &operator/**/ =();

Going to mess around with it some more today, but do you have any ideas as to why that might be happening?

[glotchimo]

In D117421#3247632, @curdeius wrote:

Could you check if your patch fixes https://github.com/llvm/llvm-project/issues/33044 as well?
If so, please add tests.

As of right now, it doesn't fix 33044. Should I investigate and see if I can get this addressed in the same patch, or should it be considered a separate bug?

[HazardyKnusperkeks]

In D117421#3249196, @glotchimo wrote:

In D117421#3247632, @curdeius wrote:

Could you check if your patch fixes https://github.com/llvm/llvm-project/issues/33044 as well?
If so, please add tests.

As of right now, it doesn't fix 33044. Should I investigate and see if I can get this addressed in the same patch, or should it be considered a separate bug?

A different one please.

[curdeius]

In D117421#3249126, @glotchimo wrote:

I was tinkering with the use of getPreviousNonComment last night before signing off and the problem that I noticed was that, though it stops the operator= from being split and aligned with previous lines, it adds a single space:

/* long long padding */ int() = default;
 int &operator()               = default;
-int &operator/**/=();
+int &operator/**/ =();

Going to mess around with it some more today, but do you have any ideas as to why that might be happening?

I don't think it's related to getPreviousNonComment, but to the fact that we add spaces after block comments.
For me it's what we expect to have.

In D117421#3249196, @glotchimo wrote:

In D117421#3247632, @curdeius wrote:

Could you check if your patch fixes https://github.com/llvm/llvm-project/issues/33044 as well?
If so, please add tests.

As of right now, it doesn't fix 33044. Should I investigate and see if I can get this addressed in the same patch, or should it be considered a separate bug?

It will be certainly a different patch, I had just thought that your patch would fix it tangentially.

[glotchimo]

Use getPreviousNonComment to account for inline comments.

[glotchimo]

clang/lib/Format/WhitespaceManager.cpp

738–745

I previously thought this would misalign other symbols succeeding operator but realize now an identifier called operator would differ from the actual keyword. Away from machine right now but will update the patch later today.

[glotchimo]

Simplify by removing look-ahead (unnecessary b/c of difference between ident and operator tokens).

[curdeius]

LGTM.
Thanks for contributing!

Let's wait a day or two before landing to let other reviewers chime in.

Do you need help landing?
If so please provide your name and email address that you'd like to be used for the commit.
Otherwise, you can request a commit access if you continue contributing (cf. https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access).

[MyDeveloperDay]

I think this LGTM

[glotchimo]

Amazing, thank you. This is my first patch so I will need help landing, but I will also apply for commit access as I intend to keep contributing. Here is my name and email for this commit: Elliott Maguire <[e-mail]>

clang/lib/Format/WhitespaceManager.cpp

unsigned PreviousOriginalWhitespaceEndOffset =
         SourceMgr.getFileOffset(PreviousOriginalWhitespaceEnd);
     assert(PreviousOriginalWhitespaceEndOffset <=
            OriginalWhitespaceStartOffset);
     const char *const PreviousOriginalWhitespaceEndData =
         SourceMgr.getCharacterData(PreviousOriginalWhitespaceEnd);
     StringRef Text(PreviousOriginalWhitespaceEndData,
                    SourceMgr.getCharacterData(OriginalWhitespaceStart) -
                        PreviousOriginalWhitespaceEndData);
-    // Usually consecutive changes would occur in consecutive tokens. This is
-    // not the case however when analyzing some preprocessor runs of the
+    // Usually consecutive changes would occur in consecutive tokens. This
+    // is not the case however when analyzing some preprocessor runs of the
     // annotated lines. For example, in this code:
     //
     // #if A // line 1
     // int i = 1;
     // #else B // line 2
     // int i = 2;
     // #endif // line 3
     //
-    // one of the runs will produce the sequence of lines marked with line 1, 2
-    // and 3. So the two consecutive whitespace changes just before '// line 2'
-    // and before '#endif // line 3' span multiple lines and tokens:
+    // one of the runs will produce the sequence of lines marked with line
+    // 1, 2 and 3. So the two consecutive whitespace changes just before '//
+    // line 2' and before '#endif // line 3' span multiple lines and tokens:
     //
     // #else B{change X}[// line 2
     // int i = 2;
     // ]{change Y}#endif // line 3
     //
-    // For this reason, if the text between consecutive changes spans multiple
-    // newlines, the token length must be adjusted to the end of the original
-    // line of the token.
+    // For this reason, if the text between consecutive changes spans
+    // multiple newlines, the token length must be adjusted to the end of
+    // the original line of the token.
     auto NewlinePos = Text.find_first_of('\n');
     if (NewlinePos == StringRef::npos) {
       Changes[i - 1].TokenLength = OriginalWhitespaceStartOffset -
                                    PreviousOriginalWhitespaceEndOffset +
                                    Changes[i].PreviousLinePostfix.size() +
                                    Changes[i - 1].CurrentLinePrefix.size();
     } else {
       Changes[i - 1].TokenLength =
           NewlinePos + Changes[i - 1].CurrentLinePrefix.size();
     }
 
-    // If there are multiple changes in this token, sum up all the changes until
-    // the end of the line.
+    // If there are multiple changes in this token, sum up all the changes
+    // until the end of the line.
     if (Changes[i - 1].IsInsideToken && Changes[i - 1].NewlinesBefore == 0)
       LastOutsideTokenChange->TokenLength +=
           Changes[i - 1].TokenLength + Changes[i - 1].Spaces;
     else
       LastOutsideTokenChange = &Changes[i - 1];
 
     Changes[i].PreviousEndOfTokenColumn =
         Changes[i - 1].StartOfTokenColumn + Changes[i - 1].TokenLength;
 
     Changes[i - 1].IsTrailingComment =
         (Changes[i].NewlinesBefore > 0 || Changes[i].Tok->is(tok::eof) ||
          (Changes[i].IsInsideToken && Changes[i].Tok->is(tok::comment))) &&
         Changes[i - 1].Tok->is(tok::comment) &&
         // FIXME: This is a dirty hack. The problem is that
-        // BreakableLineCommentSection does comment reflow changes and here is
-        // the aligning of trailing comments. Consider the case where we reflow
-        // the second line up in this example:
+        // BreakableLineCommentSection does comment reflow changes and here
+        // is the aligning of trailing comments. Consider the case where we
+        // reflow the second line up in this example:
         //
         // // line 1
         // // line 2
         //
         // That amounts to 2 changes by BreakableLineCommentSection:
-        //  - the first, delimited by (), for the whitespace between the tokens,
-        //  - and second, delimited by [], for the whitespace at the beginning
-        //  of the second token:
+        //  - the first, delimited by (), for the whitespace between the
+        //  tokens,
+        //  - and second, delimited by [], for the whitespace at the
+        //  beginning of the second token:
         //
         // // line 1(
         // )[// ]line 2
         //
         // So in the end we have two changes like this:
         //
         // // line1()[ ]line 2
         //
         // Note that the OriginalWhitespaceStart of the second change is the
         // same as the PreviousOriginalWhitespaceEnd of the first change.
-        // In this case, the below check ensures that the second change doesn't
-        // get treated as a trailing comment change here, since this might
-        // trigger additional whitespace to be wrongly inserted before "line 2"
-        // by the comment aligner here.
+        // In this case, the below check ensures that the second change
+        // doesn't get treated as a trailing comment change here, since this
+        // might trigger additional whitespace to be wrongly inserted before
+        // "line 2" by the comment aligner here.
         //
-        // For a proper solution we need a mechanism to say to WhitespaceManager
-        // that a particular change breaks the current sequence of trailing
-        // comments.
+        // For a proper solution we need a mechanism to say to
+        // WhitespaceManager that a particular change breaks the current
+        // sequence of trailing comments.
         OriginalWhitespaceStart != PreviousOriginalWhitespaceEnd;
   }
   // FIXME: The last token is currently not always an eof token; in those
   // cases, setting TokenLength of the last token to 0 is wrong.
   Changes.back().TokenLength = 0;
   Changes.back().IsTrailingComment = Changes.back().Tok->is(tok::comment);
 
   const WhitespaceManager::Change *LastBlockComment = nullptr;
   for (auto &Change : Changes) {
-    // Reset the IsTrailingComment flag for changes inside of trailing comments
-    // so they don't get realigned later. Comment line breaks however still need
-    // to be aligned.
+    // Reset the IsTrailingComment flag for changes inside of trailing
+    // comments so they don't get realigned later. Comment line breaks
+    // however still need to be aligned.
     if (Change.IsInsideToken && Change.NewlinesBefore == 0)
       Change.IsTrailingComment = false;
     Change.StartOfBlockComment = nullptr;
     Change.IndentationOffset = 0;
     if (Change.Tok->is(tok::comment)) {
       if (Change.Tok->is(TT_LineComment) || !Change.IsInsideToken)
         LastBlockComment = &Change;
       else {
         if ((Change.StartOfBlockComment = LastBlockComment))
           Change.IndentationOffset =
               Change.StartOfTokenColumn -
               Change.StartOfBlockComment->StartOfTokenColumn;
       }
     } else {
       LastBlockComment = nullptr;
     }
   }
 
   // Compute conditional nesting level
-  // Level is increased for each conditional, unless this conditional continues
-  // a chain of conditional, i.e. starts immediately after the colon of another
-  // conditional.
+  // Level is increased for each conditional, unless this conditional
+  // continues a chain of conditional, i.e. starts immediately after the colon
+  // of another conditional.
   SmallVector<bool, 16> ScopeStack;
   int ConditionalsLevel = 0;
   for (auto &Change : Changes) {
     for (unsigned i = 0, e = Change.Tok->FakeLParens.size(); i != e; ++i) {
       bool isNestedConditional =
           Change.Tok->FakeLParens[e - 1 - i] == prec::Conditional &&
           !(i == 0 && Change.Tok->Previous &&
             Change.Tok->Previous->is(TT_ConditionalExpr) &&
bool ContinuedStringLiteral = i > Start &&
                                   Changes[i - 1].Tok->is(tok::string_literal);
     bool SkipMatchCheck = InsideNestedScope || ContinuedStringLiteral;
 
     if (Changes[i].NewlinesBefore > 0 && !SkipMatchCheck) {
       Shift = 0;
       FoundMatchOnLine = false;
     }
 
-    // If this is the first matching token to be aligned, remember by how many
-    // spaces it has to be shifted, so the rest of the changes on the line are
-    // shifted by the same amount
+    // If this is the first matching token to be aligned, remember by how
+    // many spaces it has to be shifted, so the rest of the changes on the
+    // line are shifted by the same amount
     if (!FoundMatchOnLine && !SkipMatchCheck && Matches(Changes[i])) {
       FoundMatchOnLine = true;
       Shift = Column - Changes[i].StartOfTokenColumn;
       Changes[i].Spaces += Shift;
     }
 
     // This is for function parameters that are split across multiple lines,
     // as mentioned in the ScopeStack comment.
static unsigned AlignTokens(
     const FormatStyle::AlignConsecutiveStyle &ACS = FormatStyle::ACS_None) {
   unsigned MinColumn = 0;
   unsigned MaxColumn = UINT_MAX;
 
   // Line number of the start and the end of the current token sequence.
   unsigned StartOfSequence = 0;
   unsigned EndOfSequence = 0;
 
-  // Measure the scope level (i.e. depth of (), [], {}) of the first token, and
-  // abort when we hit any token in a higher scope than the starting one.
+  // Measure the scope level (i.e. depth of (), [], {}) of the first token,
+  // and abort when we hit any token in a higher scope than the starting one.
   auto IndentAndNestingLevel = StartAt < Changes.size()
                                    ? Changes[StartAt].indentAndNestingLevel()
                                    : std::tuple<unsigned, unsigned, unsigned>();
 
-  // Keep track of the number of commas before the matching tokens, we will only
-  // align a sequence of matching tokens if they are preceded by the same number
-  // of commas.
+  // Keep track of the number of commas before the matching tokens, we will
+  // only align a sequence of matching tokens if they are preceded by the same
+  // number of commas.
   unsigned CommasBeforeLastMatch = 0;
   unsigned CommasBeforeMatch = 0;
 
   // Whether a matching token has been found on the current line.
   bool FoundMatchOnLine = false;
 
   // Whether the current line consists purely of comments.
   bool LineIsComment = true;
if (Changes[i].NewlinesBefore != 0) {
       EndOfSequence = i;
 
       // Whether to break the alignment sequence because of an empty line.
       bool EmptyLineBreak =
           (Changes[i].NewlinesBefore > 1) &&
           (ACS != FormatStyle::ACS_AcrossEmptyLines) &&
           (ACS != FormatStyle::ACS_AcrossEmptyLinesAndComments);
 
-      // Whether to break the alignment sequence because of a line without a
-      // match.
+      // Whether to break the alignment sequence because of a line without
+      // a match.
       bool NoMatchBreak =
           !FoundMatchOnLine &&
           !(LineIsComment &&
             ((ACS == FormatStyle::ACS_AcrossComments) ||
              (ACS == FormatStyle::ACS_AcrossEmptyLinesAndComments)));
 
       if (EmptyLineBreak || NoMatchBreak)
         AlignCurrentSequence();
 
       // A new line starts, re-initialize line status tracking bools.
-      // Keep the match state if a string literal is continued on this line.
+      // Keep the match state if a string literal is continued on this
+      // line.
       if (i == 0 || !Changes[i].Tok->is(tok::string_literal) ||
           !Changes[i - 1].Tok->is(tok::string_literal))
         FoundMatchOnLine = false;
       LineIsComment = true;
     }
 
     if (!Changes[i].Tok->is(tok::comment)) {
       LineIsComment = false;
     }
 
     if (Changes[i].Tok->is(tok::comma)) {
       ++CommasBeforeMatch;
     } else if (Changes[i].indentAndNestingLevel() > IndentAndNestingLevel) {
       // Call AlignTokens recursively, skipping over this scope block.
       unsigned StoppedAt = AlignTokens(Style, Matches, Changes, i, ACS);
       i = StoppedAt - 1;
       continue;
     }
 
     if (!Matches(Changes[i]))
       continue;
 
-    // If there is more than one matching token per line, or if the number of
-    // preceding commas, do not match anymore, end the sequence.
+    // If there is more than one matching token per line, or if the number
+    // of preceding commas, do not match anymore, end the sequence.
     if (FoundMatchOnLine || CommasBeforeMatch != CommasBeforeLastMatch)
       AlignCurrentSequence();
 
     CommasBeforeLastMatch = CommasBeforeMatch;
     FoundMatchOnLine = true;
 
     if (StartOfSequence == 0)
       StartOfSequence = i;
 
     unsigned ChangeMinColumn = Changes[i].StartOfTokenColumn;
     int LineLengthAfter = Changes[i].TokenLength;
     for (unsigned j = i + 1; j != e && Changes[j].NewlinesBefore == 0; ++j) {
       LineLengthAfter += Changes[j].Spaces;
-      // Changes are generally 1:1 with the tokens, but a change could also be
-      // inside of a token, in which case it's counted more than once: once for
-      // the whitespace surrounding the token (!IsInsideToken) and once for
-      // each whitespace change within it (IsInsideToken).
-      // Therefore, changes inside of a token should only count the space.
+      // Changes are generally 1:1 with the tokens, but a change could
+      // also be inside of a token, in which case it's counted more than
+      // once: once for the whitespace surrounding the token
+      // (!IsInsideToken) and once for each whitespace change within it
+      // (IsInsideToken). Therefore, changes inside of a token should only
+      // count the space.
       if (!Changes[j].IsInsideToken)
         LineLengthAfter += Changes[j].TokenLength;
     }
     unsigned ChangeMaxColumn = Style.ColumnLimit - LineLengthAfter;
 
     // If we are restricted by the maximum column width, end the sequence.
     if (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn ||
         CommasBeforeLastMatch != CommasBeforeMatch) {
if (StartOfSequence > 0 && StartOfSequence < EndOfSequence) {
     int Shift = 0;
 
     for (unsigned I = StartOfSequence; I != EndOfSequence; ++I) {
       if (Changes[I].NewlinesBefore > 0) {
         Shift = 0;
         FoundMatchOnLine = false;
       }
 
-      // If this is the first matching token to be aligned, remember by how many
-      // spaces it has to be shifted, so the rest of the changes on the line are
-      // shifted by the same amount
+      // If this is the first matching token to be aligned, remember by
+      // how many spaces it has to be shifted, so the rest of the changes
+      // on the line are shifted by the same amount
       if (!FoundMatchOnLine && AlignMacrosMatches(Changes[I])) {
         FoundMatchOnLine = true;
         Shift = MinColumn - Changes[I].StartOfTokenColumn;
         Changes[I].Spaces += Shift;
       }
 
       assert(Shift >= 0);
       Changes[I].StartOfTokenColumn += Shift;
if (Changes[I].NewlinesBefore != 0) {
 
       // Whether to break the alignment sequence because of an empty line.
       bool EmptyLineBreak =
           (Changes[I].NewlinesBefore > 1) &&
           (Style.AlignConsecutiveMacros != FormatStyle::ACS_AcrossEmptyLines) &&
           (Style.AlignConsecutiveMacros !=
            FormatStyle::ACS_AcrossEmptyLinesAndComments);
 
-      // Whether to break the alignment sequence because of a line without a
-      // match.
+      // Whether to break the alignment sequence because of a line without
+      // a match.
       bool NoMatchBreak =
           !FoundMatchOnLine &&
           !(LineIsComment && ((Style.AlignConsecutiveMacros ==
                                FormatStyle::ACS_AcrossComments) ||
                               (Style.AlignConsecutiveMacros ==
                                FormatStyle::ACS_AcrossEmptyLinesAndComments)));
 
       if (EmptyLineBreak || NoMatchBreak)
AlignTokens(
         // Do not align on equal signs that are first on a line.
         if (C.NewlinesBefore > 0)
           return false;
 
         // Do not align on equal signs that are last on a line.
         if (&C != &Changes.back() && (&C + 1)->NewlinesBefore > 0)
           return false;
 
+        // Do not align operator= overloads.
+        if (C.Tok->Previous && C.Tok->Previous->is(tok::kw_operator)) {
+          auto *Next = C.Tok->Next;
+          while (Next && Next->NewlinesBefore == 0) {
+            if (Next->Tok.is(tok::l_brace))
+              return false;
+            Next = Next->Next;
+          }
+        }
+
         return C.Tok->is(tok::equal);
       },
       Changes, /*StartAt=*/0, Style.AlignConsecutiveAssignments);
 }
 
 void WhitespaceManager::alignConsecutiveBitFields() {
   if (Style.AlignConsecutiveBitFields == FormatStyle::ACS_None)
     return;
AlignTokens(
         // definitions.
         if (C.Tok->isOneOf(TT_FunctionDeclarationName, tok::kw_operator))
           return true;
         if (C.Tok->isNot(TT_StartOfName))
           return false;
         if (C.Tok->Previous &&
             C.Tok->Previous->is(TT_StatementAttributeLikeMacro))
           return false;
-        // Check if there is a subsequent name that starts the same declaration.
+        // Check if there is a subsequent name that starts the same
+        // declaration.
         for (FormatToken *Next = C.Tok->Next; Next; Next = Next->Next) {
           if (Next->is(tok::comment))
             continue;
           if (Next->is(TT_PointerOrReference))
             return false;
           if (!Next->Tok.getIdentifierInfo())
             break;
           if (Next->isOneOf(TT_StartOfName, TT_FunctionDeclarationName,
void WhitespaceManager::alignChainedConditionals() {
   } else {
     static auto AlignWrappedOperand = [](Change const &C) {
       FormatToken *Previous = C.Tok->getPreviousNonComment();
       return C.NewlinesBefore && Previous && Previous->is(TT_ConditionalExpr) &&
              (Previous->is(tok::colon) &&
               (C.Tok->FakeLParens.size() == 0 ||
                C.Tok->FakeLParens.back() != prec::Conditional));
     };
-    // Ensure we keep alignment of wrapped operands with non-wrapped operands
-    // Since we actually align the operators, the wrapped operands need the
-    // extra offset to be properly aligned.
+    // Ensure we keep alignment of wrapped operands with non-wrapped
+    // operands Since we actually align the operators, the wrapped operands
+    // need the extra offset to be properly aligned.
     for (Change &C : Changes) {
       if (AlignWrappedOperand(C))
         C.StartOfTokenColumn -= 2;
     }
     AlignTokens(
         Style,
         [this](Change const &C) {
           // Align question operators if next operand is not wrapped, as
for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
     }
     if (!Style.AlignTrailingComments || FollowsRBraceInColumn0) {
       alignTrailingComments(StartOfSequence, i, MinColumn);
       MinColumn = ChangeMinColumn;
       MaxColumn = ChangeMinColumn;
       StartOfSequence = i;
     } else if (BreakBeforeNext || Newlines > 1 ||
                (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn) ||
-               // Break the comment sequence if the previous line did not end
-               // in a trailing comment.
+               // Break the comment sequence if the previous line did not
+               // end in a trailing comment.
                (Changes[i].NewlinesBefore == 1 && i > 0 &&
                 !Changes[i - 1].IsTrailingComment) ||
                WasAlignedWithStartOfNextLine) {
       alignTrailingComments(StartOfSequence, i, MinColumn);
       MinColumn = ChangeMinColumn;
       MaxColumn = ChangeMaxColumn;
       StartOfSequence = i;
     } else {
if (Depth == 2) {
           ++Cell;
       }
     } else if (Depth == 1) {
       if (C.Tok == MatchingParen) {
         if (!Cells.empty())
           Cells.back().EndIndex = i;
         Cells.push_back(CellDescription{i, ++Cell, i + 1, false, nullptr});
         CellCount = C.Tok->Previous->isNot(tok::comma) ? Cell + 1 : Cell;
-        // Go to the next non-comment and ensure there is a break in front
+        // Go to the next non-comment and ensure there is a break in
+        // front
         const auto *NextNonComment = C.Tok->getNextNonComment();
         while (NextNonComment->is(tok::comma))
           NextNonComment = NextNonComment->getNextNonComment();
         auto j = i;
         while (Changes[j].Tok != NextNonComment && j < End)
           ++j;
         if (j < End && Changes[j].NewlinesBefore == 0 &&
             Changes[j].Tok->isNot(tok::r_brace)) {
if (Depth == 2) {
       C.NewlinesBefore = 1;
       C.Spaces = EndSpaces;
     }
     if (C.Tok->StartsColumn) {
       // This gets us past tokens that have been split over multiple
       // lines
       bool HasSplit = false;
       if (Changes[i].NewlinesBefore > 0) {
-        // So if we split a line previously and the tail line + this token is
-        // less then the column limit we remove the split here and just put
-        // the column start at a space past the comma
+        // So if we split a line previously and the tail line + this
+        // token is less then the column limit we remove the split here
+        // and just put the column start at a space past the comma
         //
         // FIXME This if branch covers the cases where the column is not
-        // the first column. This leads to weird pathologies like the formatting
-        // auto foo = Items{
+        // the first column. This leads to weird pathologies like the
+        // formatting auto foo = Items{
         //     Section{
         //             0, bar(),
         //     }
         // };
         // Well if it doesn't lead to that it's indicative that the line
-        // breaking should be revisited. Unfortunately alot of other options
-        // interact with this
+        // breaking should be revisited. Unfortunately alot of other
+        // options interact with this
         auto j = i - 1;
         if ((j - 1) > Start && Changes[j].Tok->is(tok::comma) &&
             Changes[j - 1].NewlinesBefore > 0) {
           --j;
           auto LineLimit = Changes[j].Spaces + Changes[j].TokenLength;
           if (LineLimit < Style.ColumnLimit) {
             Changes[i].NewlinesBefore = 0;
             Changes[i].Spaces = 1;
for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
     if (C.CreateReplacement) {
       std::string ReplacementText = C.PreviousLinePostfix;
       if (C.ContinuesPPDirective)
         appendEscapedNewlineText(ReplacementText, C.NewlinesBefore,
                                  C.PreviousEndOfTokenColumn,
                                  C.EscapedNewlineColumn);
       else
         appendNewlineText(ReplacementText, C.NewlinesBefore);
-      // FIXME: This assert should hold if we computed the column correctly.
-      // assert((int)C.StartOfTokenColumn >= C.Spaces);
+      // FIXME: This assert should hold if we computed the column
+      // correctly. assert((int)C.StartOfTokenColumn >= C.Spaces);
       appendIndentText(
           ReplacementText, C.Tok->IndentLevel, std::max(0, C.Spaces),
           std::max((int)C.StartOfTokenColumn, C.Spaces) - std::max(0, C.Spaces),
           C.IsAligned);
       ReplacementText.append(C.CurrentLinePrefix);
       storeReplacement(C.OriginalWhitespaceRange, ReplacementText);
     }
   }
case FormatStyle::UT_AlignWithSpaces:
     }
     Text.append(Spaces, ' ');
     break;
   }
 }
 
 unsigned WhitespaceManager::appendTabIndent(std::string &Text, unsigned Spaces,
                                             unsigned Indentation) {
-  // This happens, e.g. when a line in a block comment is indented less than the
-  // first one.
+  // This happens, e.g. when a line in a block comment is indented less than
+  // the first one.
   if (Indentation > Spaces)
     Indentation = Spaces;
   if (Style.TabWidth) {
     unsigned Tabs = Indentation / Style.TabWidth;
     Text.append(Tabs, '\t');
     Spaces -= Tabs * Style.TabWidth;
   }
   return Spaces;
 }
 
 } // namespace format
 } // namespace clang

clang/unittests/Format/FormatTest.cpp

verifyFormat("int a   = 5;\n"
                Alignment);
   verifyFormat("int oneTwoThree = 123;\n"
                "int oneTwo      = 12;\n"
                "method();\n",
                Alignment);
   verifyFormat("int oneTwoThree = 123; // comment\n"
                "int oneTwo      = 12;  // comment",
                Alignment);
+  verifyFormat("int()           = default;\n"
+               "int &operator() = default;\n"
+               "int &operator=() {",
+               Alignment);
+  verifyFormat("int()           = default; // comment\n"
+               "int &operator() = default; // comment\n"
+               "int &operator=() {",
+               Alignment);
 
   // Bug 25167
   /* Uncomment when fixed
     verifyFormat("#if A\n"
                  "#else\n"
                  "int aaaaaaaa = 12;\n"
                  "#endif\n"
                  "#if B\n"
                  "#else\n"
                  "int a = 12;\n"
                  "#endif\n",
                  Alignment);
     verifyFormat("enum foo {\n"
                  "#if A\n"
                  "#else\n"
                  "  aaaaaaaa = 12;\n"
                  "#endif\n"
                  "#if B\n"
                  "#else\n"
                  "  a = 12;\n"