[clang-format] NOT FOR COMMIT - Demo of AutomaticBraces: Remove

[MyDeveloperDay]

Summary

This is not for committing its a clang-format on clang/lib/Format/TokenAnnotator.cpp with an option to remove braces from single line if/for (LLVM style)

[HazardyKnusperkeks]

clang/lib/Format/TokenAnnotator.cpp

3230

Here we really have an error!

clang/lib/Format/TokenAnnotator.cpp

if (Left->is(TT_OverloadedOperatorLParen)) {
       // i.e. the operator is called as a member function,
       // then the argument must be an expression.
       bool OperatorCalledAsMemberFunction =
           Prev->Previous && Prev->Previous->isOneOf(tok::period, tok::arrow);
       Contexts.back().IsExpression = OperatorCalledAsMemberFunction;
     } else if (Style.Language == FormatStyle::LK_JavaScript &&
                (Line.startsWith(Keywords.kw_type, tok::identifier) ||
                 Line.startsWith(tok::kw_export, Keywords.kw_type,
-                                tok::identifier))) {
+                                tok::identifier)))
       // type X = (...);
       // export type X = (...);
       Contexts.back().IsExpression = false;
-    } else if (Left->Previous &&
-               (Left->Previous->isOneOf(tok::kw_static_assert, tok::kw_while,
-                                        tok::l_paren, tok::comma) ||
-                Left->Previous->isIf() ||
-                Left->Previous->is(TT_BinaryOperator))) {
+    else if (Left->Previous &&
+              Left->Previous->isIf() || Left->Previous->is(TT_BinaryOperator)))
       // static_assert, if and while usually contain expressions.
       Contexts.back().IsExpression = true;
-    } else if (Style.Language == FormatStyle::LK_JavaScript && Left->Previous &&
-               (Left->Previous->is(Keywords.kw_function) ||
-                (Left->Previous->endsSequence(tok::identifier,
-                                              Keywords.kw_function)))) {
+    else if (Style.Language == FormatStyle::LK_JavaScript && Left->Previous &&
+                                            Keywords.kw_function))))
       // function(...) or function f(...)
       Contexts.back().IsExpression = false;
-    } else if (Style.Language == FormatStyle::LK_JavaScript && Left->Previous &&
-               Left->Previous->is(TT_JsTypeColon)) {
+    else if (Style.Language == FormatStyle::LK_JavaScript && Left->Previous &&
+             Left->Previous->is(TT_JsTypeColon))
       // let x: (SomeType);
       Contexts.back().IsExpression = false;
-    } else if (isLambdaParameterList(Left)) {
+    else if (isLambdaParameterList(Left))
       // This is a parameter list of a lambda expression.
       Contexts.back().IsExpression = false;
-    } else if (Line.InPPDirective &&
-               (!Left->Previous || !Left->Previous->is(tok::identifier))) {
+    else if (Line.InPPDirective &&
+             (!Left->Previous || !Left->Previous->is(tok::identifier)))
       Contexts.back().IsExpression = true;
-    } else if (Contexts[Contexts.size() - 2].CaretFound) {
+    else if (Contexts[Contexts.size() - 2].CaretFound)
       // This is the parameter list of an ObjC block.
       Contexts.back().IsExpression = false;
-    } else if (Left->Previous && Left->Previous->is(TT_ForEachMacro)) {
+    else if (Left->Previous && Left->Previous->is(TT_ForEachMacro)) {
       // The first argument to a foreach macro is a declaration.
       Contexts.back().IsForEachMacro = true;
       Contexts.back().IsExpression = false;
     } else if (Left->Previous && Left->Previous->MatchingParen &&
-               Left->Previous->MatchingParen->is(TT_ObjCBlockLParen)) {
+               Left->Previous->MatchingParen->is(TT_ObjCBlockLParen))
       Contexts.back().IsExpression = false;
-    } else if (!Line.MustBeDeclaration && !Line.InPPDirective) {
+    else if (!Line.MustBeDeclaration && !Line.InPPDirective) {
       bool IsForOrCatch =
           Left->Previous && Left->Previous->isOneOf(tok::kw_for, tok::kw_catch);
       Contexts.back().IsExpression = !IsForOrCatch;
     }
 
     // Infer the role of the l_paren based on the previous token if we haven't
     // detected one one yet.
     if (PrevNonComment && Left->is(TT_Unknown)) {
while (CurrentToken) {
         Left->MatchingParen = CurrentToken;
         CurrentToken->MatchingParen = Left;
 
         if (CurrentToken->Next && CurrentToken->Next->is(tok::l_brace) &&
             Left->Previous && Left->Previous->is(tok::l_paren)) {
           // Detect the case where macros are used to generate lambdas or
           // function bodies, e.g.:
           //   auto my_lambda = MACRO((Type *type, int i) { .. body .. });
-          for (FormatToken *Tok = Left; Tok != CurrentToken; Tok = Tok->Next) {
+          for (FormatToken *Tok = Left; Tok != CurrentToken; Tok = Tok->Next)
             if (Tok->is(TT_BinaryOperator) &&
                 Tok->isOneOf(tok::star, tok::amp, tok::ampamp))
               Tok->setType(TT_PointerOrReference);
-          }
-        }
 
         if (StartsObjCMethodExpr) {
           CurrentToken->setType(TT_ObjCMethodExpr);
           if (Contexts.back().FirstObjCSelectorName) {
             Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
                 Contexts.back().LongestObjCSelectorName;
           }
         }
bool isCSharpAttributeSpecifier(const FormatToken &Tok) {
     if (!AttrTok)
       return false;
 
     // Just an empty declaration e.g. string [].
     if (AttrTok->is(tok::r_square))
       return false;
 
     // Move along the tokens inbetween the '[' and ']' e.g. [STAThread].
-    while (AttrTok && AttrTok->isNot(tok::r_square)) {
+    while (AttrTok && AttrTok->isNot(tok::r_square))
       AttrTok = AttrTok->Next;
-    }
 
     if (!AttrTok)
       return false;
 
     // Allow an attribute to be the only content of a file.
     AttrTok = AttrTok->Next;
     if (!AttrTok)
       return true;
 
     // Limit this to being an access modifier that follows.
     if (AttrTok->isOneOf(tok::kw_public, tok::kw_private, tok::kw_protected,
                          tok::comment, tok::kw_class, tok::kw_static,
-                         tok::l_square, Keywords.kw_internal)) {
+                         tok::l_square, Keywords.kw_internal))
       return true;
-    }
 
     // incase its a [XXX] retval func(....
     if (AttrTok->Next &&
         AttrTok->Next->startsSequence(tok::identifier, tok::l_paren))
       return true;
 
     return false;
   }
 
   bool isCpp11AttributeSpecifier(const FormatToken &Tok) {
     if (!Style.isCpp() || !Tok.startsSequence(tok::l_square, tok::l_square))
       return false;
     // The first square bracket is part of an ObjC array literal
-    if (Tok.Previous && Tok.Previous->is(tok::at)) {
+    if (Tok.Previous && Tok.Previous->is(tok::at))
       return false;
-    }
+
     const FormatToken *AttrTok = Tok.Next->Next;
     if (!AttrTok)
       return false;
     // C++17 '[[using ns: foo, bar(baz, blech)]]'
     // We assume nobody will name an ObjC variable 'using'.
     if (AttrTok->startsSequence(tok::kw_using, tok::identifier, tok::colon))
       return true;
     if (AttrTok->isNot(tok::identifier))
bool StartsObjCMethodExpr =
          Parent->isUnaryOperator() ||
          // FIXME(bug 36976): ObjC return types shouldn't use TT_CastRParen.
          Parent->isOneOf(TT_ObjCForIn, TT_CastRParen) ||
          (getBinOpPrecedence(Parent->Tok.getKind(), true, true) >
           prec::Unknown));
     bool ColonFound = false;
 
     unsigned BindingIncrease = 1;
-    if (IsCppStructuredBinding) {
+    if (IsCppStructuredBinding)
       Left->setType(TT_StructuredBindingLSquare);
-    } else if (Left->is(TT_Unknown)) {
+    else if (Left->is(TT_Unknown)) {
       if (StartsObjCMethodExpr) {
         Left->setType(TT_ObjCMethodExpr);
-      } else if (InsideInlineASM) {
+      } else if (InsideInlineASM)
         Left->setType(TT_InlineASMSymbolicNameLSquare);
-      } else if (IsCpp11AttributeSpecifier) {
+      else if (IsCpp11AttributeSpecifier)
         Left->setType(TT_AttributeSquare);
-      } else if (Style.Language == FormatStyle::LK_JavaScript && Parent &&
-                 Contexts.back().ContextKind == tok::l_brace &&
-                 Parent->isOneOf(tok::l_brace, tok::comma)) {
+      else if (Style.Language == FormatStyle::LK_JavaScript && Parent &&
+               Parent->isOneOf(tok::l_brace, tok::comma))
         Left->setType(TT_JsComputedPropertyName);
-      } else if (Style.isCpp() && Contexts.back().ContextKind == tok::l_brace &&
-                 Parent && Parent->isOneOf(tok::l_brace, tok::comma)) {
+      else if (Style.isCpp() && Contexts.back().ContextKind == tok::l_brace &&
+               Parent && Parent->isOneOf(tok::l_brace, tok::comma))
         Left->setType(TT_DesignatedInitializerLSquare);
-      } else if (IsCSharpAttributeSpecifier) {
+      else if (IsCSharpAttributeSpecifier)
         Left->setType(TT_AttributeSquare);
-      } else if (CurrentToken->is(tok::r_square) && Parent &&
-                 Parent->is(TT_TemplateCloser)) {
+      else if (CurrentToken->is(tok::r_square) && Parent &&
+               Parent->is(TT_TemplateCloser))
         Left->setType(TT_ArraySubscriptLSquare);
-      } else if (Style.Language == FormatStyle::LK_Proto ||
-                 Style.Language == FormatStyle::LK_TextProto) {
+      else if (Style.Language == FormatStyle::LK_Proto ||
         // Square braces in LK_Proto can either be message field attributes:
         //
         // optional Aaa aaa = 1 [
         //   (aaa) = aaa
         // ];
         //
         // extensions 123 [
         //   (aaa) = aaa
else if (Left->is(TT_Unknown)) {
           Left->setType(TT_ProtoExtensionLSquare);
           BindingIncrease = 10;
         }
       } else if (!CppArrayTemplates && Parent &&
                  Parent->isOneOf(TT_BinaryOperator, TT_TemplateCloser, tok::at,
                                  tok::comma, tok::l_paren, tok::l_square,
                                  tok::question, tok::colon, tok::kw_return,
                                  // Should only be relevant to JavaScript:
-                                 tok::kw_default)) {
+                                 tok::kw_default))
         Left->setType(TT_ArrayInitializerLSquare);
-      } else {
+      else {
         BindingIncrease = 10;
         Left->setType(TT_ArraySubscriptLSquare);
       }
     }
 
     ScopedContextCreator ContextCreator(*this, tok::l_square, BindingIncrease);
     Contexts.back().IsExpression = true;
     if (Style.Language == FormatStyle::LK_JavaScript && Parent &&
while (CurrentToken) {
         // Here, we set FirstObjCSelectorName when the end of the method call is
         // reached, in case it was not set already.
         if (!Contexts.back().FirstObjCSelectorName) {
           FormatToken *Previous = CurrentToken->getPreviousNonComment();
           if (Previous && Previous->is(TT_SelectorName)) {
             Previous->ObjCSelectorNameParts = 1;
             Contexts.back().FirstObjCSelectorName = Previous;
           }
-        } else {
+        } else
           Left->ParameterCount =
               Contexts.back().FirstObjCSelectorName->ObjCSelectorNameParts;
-        }
+
         if (Contexts.back().FirstObjCSelectorName) {
           Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
               Contexts.back().LongestObjCSelectorName;
           if (Left->BlockParameterCount > 1)
             Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName = 0;
         }
         next();
         return true;
private:
   bool couldBeInStructArrayInitializer() const {
     if (Contexts.size() < 2)
       return false;
     // We want to back up no more then 2 context levels i.e.
     // . { { <-
     const auto End = std::next(Contexts.rbegin(), 2);
     auto Last = Contexts.rbegin();
     unsigned Depth = 0;
-    for (; Last != End; ++Last) {
+    for (; Last != End; ++Last)
       if (Last->ContextKind == tok::l_brace)
         ++Depth;
-    }
+
     return Depth == 2 && Last->ContextKind != tok::l_brace;
   }
 
   bool parseBrace() {
     if (CurrentToken) {
       FormatToken *Left = CurrentToken->Previous;
       Left->ParentBracket = Contexts.back().ContextKind;
 
if (CurrentToken) {
 
       unsigned CommaCount = 0;
       while (CurrentToken) {
         if (CurrentToken->is(tok::r_brace)) {
           Left->MatchingParen = CurrentToken;
           CurrentToken->MatchingParen = Left;
           if (Style.AlignArrayOfStructures != FormatStyle::AIAS_None) {
             if (Left->ParentBracket == tok::l_brace &&
-                couldBeInStructArrayInitializer() && CommaCount > 0) {
+                couldBeInStructArrayInitializer() && CommaCount > 0)
               Contexts.back().InStructArrayInitializer = true;
-            }
-          }
           next();
           return true;
         }
         if (CurrentToken->isOneOf(tok::r_paren, tok::r_square))
           return false;
         updateParameterCount(Left, CurrentToken);
         if (CurrentToken->isOneOf(tok::colon, tok::l_brace, tok::less)) {
           FormatToken *Previous = CurrentToken->getPreviousNonComment();
void updateParameterCount(FormatToken *Left, FormatToken *Current) {
     // inside a bracket scope).
     if (Current->is(tok::l_brace) && Current->is(BK_Block))
       ++Left->BlockParameterCount;
     if (Current->is(tok::comma)) {
       ++Left->ParameterCount;
       if (!Left->Role)
         Left->Role.reset(new CommaSeparatedList(Style));
       Left->Role->CommaFound(Current);
-    } else if (Left->ParameterCount == 0 && Current->isNot(tok::comment)) {
+    } else if (Left->ParameterCount == 0 && Current->isNot(tok::comment))
       Left->ParameterCount = 1;
-    }
-  }
 
   bool parseConditional() {
     while (CurrentToken) {
       if (CurrentToken->is(tok::colon)) {
         CurrentToken->setType(TT_ConditionalExpr);
         next();
         return true;
       }
case tok::colon:
           else if (Tok->Previous->ColumnWidth >
                    Contexts.back().LongestObjCSelectorName)
             Contexts.back().LongestObjCSelectorName =
                 Tok->Previous->ColumnWidth;
           Tok->Previous->ParameterIndex =
               Contexts.back().FirstObjCSelectorName->ObjCSelectorNameParts;
           ++Contexts.back().FirstObjCSelectorName->ObjCSelectorNameParts;
         }
-      } else if (Contexts.back().ColonIsForRangeExpr) {
+      } else if (Contexts.back().ColonIsForRangeExpr)
         Tok->setType(TT_RangeBasedForLoopColon);
-      } else if (CurrentToken && CurrentToken->is(tok::numeric_constant)) {
+      else if (CurrentToken && CurrentToken->is(tok::numeric_constant))
         Tok->setType(TT_BitFieldColon);
-      } else if (Contexts.size() == 1 &&
-                 !Line.First->isOneOf(tok::kw_enum, tok::kw_case,
-                                      tok::kw_default)) {
+      else if (Contexts.size() == 1 &&
         FormatToken *Prev = Tok->getPreviousNonComment();
         if (Prev->isOneOf(tok::r_paren, tok::kw_noexcept))
           Tok->setType(TT_CtorInitializerColon);
         else if (Prev->is(tok::kw_try)) {
           // Member initializer list within function try block.
           FormatToken *PrevPrev = Prev->getPreviousNonComment();
           if (PrevPrev && PrevPrev->isOneOf(tok::r_paren, tok::kw_noexcept))
             Tok->setType(TT_CtorInitializerColon);
         } else
           Tok->setType(TT_InheritanceColon);
       } else if (canBeObjCSelectorComponent(*Tok->Previous) && Tok->Next &&
                  (Tok->Next->isOneOf(tok::r_paren, tok::comma) ||
                   (canBeObjCSelectorComponent(*Tok->Next) && Tok->Next->Next &&
                    Tok->Next->Next->is(tok::colon)))) {
         // This handles a special macro in ObjC code where selectors including
         // the colon are passed as macro arguments.
         Tok->setType(TT_ObjCMethodExpr);
-      } else if (Contexts.back().ContextKind == tok::l_paren) {
+      } else if (Contexts.back().ContextKind == tok::l_paren)
         Tok->setType(TT_InlineASMColon);
-      }
+
       break;
     case tok::pipe:
     case tok::amp:
       // | and & in declarations/type expressions represent union and
       // intersection types, respectively.
       if (Style.Language == FormatStyle::LK_JavaScript &&
           !Contexts.back().IsExpression)
         Tok->setType(TT_JsTypeOperator);
case tok::comma:
         Contexts.back().FirstStartOfName->PartOfMultiVariableDeclStmt = true;
         Line.IsMultiVariableDeclStmt = true;
       }
       if (Contexts.back().IsForEachMacro)
         Contexts.back().IsExpression = true;
       break;
     case tok::identifier:
       if (Tok->isOneOf(Keywords.kw___has_include,
-                       Keywords.kw___has_include_next)) {
+                       Keywords.kw___has_include_next))
         parseHasInclude();
-      }
+
       if (Style.isCSharp() && Tok->is(Keywords.kw_where) && Tok->Next &&
           Tok->Next->isNot(tok::l_paren)) {
         Tok->setType(TT_CSharpGenericTypeConstraint);
         parseCSharpGenericTypeConstraint();
       }
       break;
     default:
       break;
while (CurrentToken) {
         CurrentToken->setType(TT_CSharpGenericTypeConstraintComma);
         next();
       } else if (CurrentToken->is(Keywords.kw_where)) {
         CurrentToken->setType(TT_CSharpGenericTypeConstraint);
         next();
       } else if (CurrentToken->is(tok::colon)) {
         CurrentToken->setType(TT_CSharpGenericTypeConstraintColon);
         next();
-      } else {
+      } else
         next();
-      }
-    }
-  }
 
   void parseIncludeDirective() {
     if (CurrentToken && CurrentToken->is(tok::less)) {
       next();
       while (CurrentToken) {
         // Mark tokens up to the trailing line comments as implicit string
         // literals.
         if (CurrentToken->isNot(tok::comment) &&
if (Current.getPrecedence() == prec::Assignment &&
             break;
           if (Previous->isOneOf(TT_BinaryOperator, TT_UnaryOperator) &&
               Previous->isOneOf(tok::star, tok::amp, tok::ampamp) &&
               Previous->Previous && Previous->Previous->isNot(tok::equal))
             Previous->setType(TT_PointerOrReference);
         }
       }
     } else if (Current.is(tok::lessless) &&
-               (!Current.Previous || !Current.Previous->is(tok::kw_operator))) {
+               (!Current.Previous || !Current.Previous->is(tok::kw_operator)))
       Contexts.back().IsExpression = true;
-    } else if (Current.isOneOf(tok::kw_return, tok::kw_throw)) {
+    else if (Current.isOneOf(tok::kw_return, tok::kw_throw))
       Contexts.back().IsExpression = true;
-    } else if (Current.is(TT_TrailingReturnArrow)) {
+    else if (Current.is(TT_TrailingReturnArrow))
       Contexts.back().IsExpression = false;
-    } else if (Current.is(TT_LambdaArrow) || Current.is(Keywords.kw_assert)) {
+    else if (Current.is(TT_LambdaArrow) || Current.is(Keywords.kw_assert))
       Contexts.back().IsExpression = Style.Language == FormatStyle::LK_Java;
-    } else if (Current.Previous &&
-               Current.Previous->is(TT_CtorInitializerColon)) {
+    else if (Current.Previous &&
       Contexts.back().IsExpression = true;
       Contexts.back().InCtorInitializer = true;
-    } else if (Current.Previous && Current.Previous->is(TT_InheritanceColon)) {
+    } else if (Current.Previous && Current.Previous->is(TT_InheritanceColon))
       Contexts.back().InInheritanceList = true;
-    } else if (Current.isOneOf(tok::r_paren, tok::greater, tok::comma)) {
+    else if (Current.isOneOf(tok::r_paren, tok::greater, tok::comma)) {
       for (FormatToken *Previous = Current.Previous;
            Previous && Previous->isOneOf(tok::star, tok::amp);
            Previous = Previous->Previous)
         Previous->setType(TT_PointerOrReference);
       if (Line.MustBeDeclaration && !Contexts.front().InCtorInitializer)
         Contexts.back().IsExpression = false;
-    } else if (Current.is(tok::kw_new)) {
+    } else if (Current.is(tok::kw_new))
       Contexts.back().CanBeExpression = false;
-    } else if (Current.is(tok::semi) ||
-               (Current.is(tok::exclaim) && Current.Previous &&
-                !Current.Previous->is(tok::kw_operator))) {
+    else if (Current.is(tok::semi) ||
+              !Current.Previous->is(tok::kw_operator)))
       // This should be the condition or increment in a for-loop.
       // But not operator !() (can't use TT_OverloadedOperator here as its not
       // been annotated yet).
       Contexts.back().IsExpression = true;
-    }
-  }
 
   static FormatToken *untilMatchingParen(FormatToken *Current) {
     // Used when `MatchingParen` is not yet established.
     int ParenLevel = 0;
     while (Current) {
       if (Current->is(tok::l_paren))
         ParenLevel++;
       if (Current->is(tok::r_paren))
static bool isDeductionGuide(FormatToken &Current) {
     // Look for a deduction guide template<T> A(...) -> A<...>;
     if (Current.Previous && Current.Previous->is(tok::r_paren) &&
         Current.startsSequence(tok::arrow, tok::identifier, tok::less)) {
       // Find the TemplateCloser.
       FormatToken *TemplateCloser = Current.Next->Next;
       int NestingLevel = 0;
       while (TemplateCloser) {
         // Skip over an expressions in parens  A<(3 < 2)>;
-        if (TemplateCloser->is(tok::l_paren)) {
+        if (TemplateCloser->is(tok::l_paren))
           // No Matching Paren yet so skip to matching paren
           TemplateCloser = untilMatchingParen(TemplateCloser);
-        }
+
         if (TemplateCloser->is(tok::less))
           NestingLevel++;
         if (TemplateCloser->is(tok::greater))
           NestingLevel--;
         if (NestingLevel < 1)
           break;
         TemplateCloser = TemplateCloser->Next;
       }
if ((Style.Language == FormatStyle::LK_JavaScript || Style.isCSharp()) &&
         Current.setType(TT_NonNullAssertion);
         return;
       }
     }
 
     // Line.MightBeFunctionDecl can only be true after the parentheses of a
     // function declaration have been found. In this case, 'Current' is a
     // trailing token of this declaration and thus cannot be a name.
-    if (Current.is(Keywords.kw_instanceof)) {
+    if (Current.is(Keywords.kw_instanceof))
       Current.setType(TT_BinaryOperator);
-    } else if (isStartOfName(Current) &&
-               (!Line.MightBeFunctionDecl || Current.NestingLevel != 0)) {
+    else if (isStartOfName(Current) &&
       Contexts.back().FirstStartOfName = &Current;
       Current.setType(TT_StartOfName);
-    } else if (Current.is(tok::semi)) {
+    } else if (Current.is(tok::semi))
       // Reset FirstStartOfName after finding a semicolon so that a for loop
       // with multiple increment statements is not confused with a for loop
       // having multiple variable declarations.
       Contexts.back().FirstStartOfName = nullptr;
-    } else if (Current.isOneOf(tok::kw_auto, tok::kw___auto_type)) {
+    else if (Current.isOneOf(tok::kw_auto, tok::kw___auto_type))
       AutoFound = true;
-    } else if (Current.is(tok::arrow) &&
-               Style.Language == FormatStyle::LK_Java) {
+    else if (Current.is(tok::arrow) && Style.Language == FormatStyle::LK_Java)
       Current.setType(TT_LambdaArrow);
-    } else if (Current.is(tok::arrow) && AutoFound && Line.MustBeDeclaration &&
-               Current.NestingLevel == 0 &&
-               !Current.Previous->is(tok::kw_operator)) {
+    else if (Current.is(tok::arrow) && AutoFound && Line.MustBeDeclaration &&
+             !Current.Previous->is(tok::kw_operator))
       // not auto operator->() -> xxx;
       Current.setType(TT_TrailingReturnArrow);
-    } else if (Current.is(tok::arrow) && Current.Previous &&
-               Current.Previous->is(tok::r_brace)) {
+    else if (Current.is(tok::arrow) && Current.Previous &&
+             Current.Previous->is(tok::r_brace))
       // Concept implicit conversion constraint needs to be treated like
       // a trailing return type  ... } -> <type>.
       Current.setType(TT_TrailingReturnArrow);
-    } else if (isDeductionGuide(Current)) {
+    else if (isDeductionGuide(Current))
       // Deduction guides trailing arrow " A(...) -> A<T>;".
       Current.setType(TT_TrailingReturnArrow);
-    } else if (Current.isOneOf(tok::star, tok::amp, tok::ampamp)) {
+    else if (Current.isOneOf(tok::star, tok::amp, tok::ampamp))
       Current.setType(determineStarAmpUsage(
           Current,
           Contexts.back().CanBeExpression && Contexts.back().IsExpression,
           Contexts.back().InTemplateArgument));
-    } else if (Current.isOneOf(tok::minus, tok::plus, tok::caret)) {
+    else if (Current.isOneOf(tok::minus, tok::plus, tok::caret)) {
       Current.setType(determinePlusMinusCaretUsage(Current));
       if (Current.is(TT_UnaryOperator) && Current.is(tok::caret))
         Contexts.back().CaretFound = true;
-    } else if (Current.isOneOf(tok::minusminus, tok::plusplus)) {
+    } else if (Current.isOneOf(tok::minusminus, tok::plusplus))
       Current.setType(determineIncrementUsage(Current));
-    } else if (Current.isOneOf(tok::exclaim, tok::tilde)) {
+    else if (Current.isOneOf(tok::exclaim, tok::tilde))
       Current.setType(TT_UnaryOperator);
-    } else if (Current.is(tok::question)) {
+    else if (Current.is(tok::question)) {
       if (Style.Language == FormatStyle::LK_JavaScript &&
           Line.MustBeDeclaration && !Contexts.back().IsExpression) {
         // In JavaScript, `interface X { foo?(): bar; }` is an optional method
         // on the interface, not a ternary expression.
         Current.setType(TT_JsTypeOptionalQuestion);
-      } else {
+      } else
         Current.setType(TT_ConditionalExpr);
-      }
+
     } else if (Current.isBinaryOperator() &&
                (!Current.Previous || Current.Previous->isNot(tok::l_square)) &&
                (!Current.is(tok::greater) &&
-                Style.Language != FormatStyle::LK_TextProto)) {
+                Style.Language != FormatStyle::LK_TextProto))
       Current.setType(TT_BinaryOperator);
-    } else if (Current.is(tok::comment)) {
+    else if (Current.is(tok::comment)) {
       if (Current.TokenText.startswith("/*")) {
         if (Current.TokenText.endswith("*/"))
           Current.setType(TT_BlockComment);
         else
           // The lexer has for some reason determined a comment here. But we
           // cannot really handle it, if it isn't properly terminated.
           Current.Tok.setKind(tok::unknown);
       } else {
         Current.setType(TT_LineComment);
       }
     } else if (Current.is(tok::r_paren)) {
       if (rParenEndsCast(Current))
         Current.setType(TT_CastRParen);
       if (Current.MatchingParen && Current.Next &&
           !Current.Next->isBinaryOperator() &&
           !Current.Next->isOneOf(tok::semi, tok::colon, tok::l_brace,
                                  tok::comma, tok::period, tok::arrow,
                                  tok::coloncolon))
         if (FormatToken *AfterParen = Current.MatchingParen->Next) {
           // Make sure this isn't the return type of an Obj-C block declaration
-          if (AfterParen->Tok.isNot(tok::caret)) {
+          if (AfterParen->Tok.isNot(tok::caret))
             if (FormatToken *BeforeParen = Current.MatchingParen->Previous)
               if (BeforeParen->is(tok::identifier) &&
                   !BeforeParen->is(TT_TypenameMacro) &&
                   BeforeParen->TokenText == BeforeParen->TokenText.upper() &&
                   (!BeforeParen->Previous ||
                    BeforeParen->Previous->ClosesTemplateDeclaration))
                 Current.setType(TT_FunctionAnnotationRParen);
-          }
-        }
     } else if (Current.is(tok::at) && Current.Next &&
                Style.Language != FormatStyle::LK_JavaScript &&
                Style.Language != FormatStyle::LK_Java) {
       // In Java & JavaScript, "@..." is a decorator or annotation. In ObjC, it
       // marks declarations and properties that need special formatting.
       switch (Current.Next->Tok.getObjCKeywordID()) {
       case tok::objc_interface:
       case tok::objc_implementation:
else if (Current.is(tok::comment)) {
       }
     } else if (canBeObjCSelectorComponent(Current) &&
                // FIXME(bug 36976): ObjC return types shouldn't use
                // TT_CastRParen.
                Current.Previous && Current.Previous->is(TT_CastRParen) &&
                Current.Previous->MatchingParen &&
                Current.Previous->MatchingParen->Previous &&
                Current.Previous->MatchingParen->Previous->is(
-                   TT_ObjCMethodSpecifier)) {
+                   TT_ObjCMethodSpecifier))
       // This is the first part of an Objective-C selector name. (If there's no
       // colon after this, this is the only place which annotates the identifier
       // as a selector.)
       Current.setType(TT_SelectorName);
-    } else if (Current.isOneOf(tok::identifier, tok::kw_const, tok::kw_noexcept,
-                               tok::kw_requires) &&
-               Current.Previous &&
-               !Current.Previous->isOneOf(tok::equal, tok::at) &&
-               Line.MightBeFunctionDecl && Contexts.size() == 1) {
+    else if (Current.isOneOf(tok::identifier, tok::kw_const, tok::kw_noexcept,
+             Line.MightBeFunctionDecl && Contexts.size() == 1)
       // Line.MightBeFunctionDecl can only be true after the parentheses of a
       // function declaration have been found.
       Current.setType(TT_TrailingAnnotation);
-    } else if ((Style.Language == FormatStyle::LK_Java ||
-                Style.Language == FormatStyle::LK_JavaScript) &&
-               Current.Previous) {
+    else if ((Style.Language == FormatStyle::LK_Java ||
       if (Current.Previous->is(tok::at) &&
           Current.isNot(Keywords.kw_interface)) {
         const FormatToken &AtToken = *Current.Previous;
         const FormatToken *Previous = AtToken.getPreviousNonComment();
         if (!Previous || Previous->is(TT_LeadingJavaAnnotation))
           Current.setType(TT_LeadingJavaAnnotation);
         else
           Current.setType(TT_JavaAnnotation);
for (const FormatToken *Token = Tok.MatchingParen->Next; Token != &Tok;
         return false;
 
     // If the following token is an identifier or 'this', this is a cast. All
     // cases where this can be something else are handled above.
     if (Tok.Next->isOneOf(tok::identifier, tok::kw_this))
       return true;
 
     // Look for a cast `( x ) (`.
-    if (Tok.Next->is(tok::l_paren) && Tok.Previous && Tok.Previous->Previous) {
+    if (Tok.Next->is(tok::l_paren) && Tok.Previous && Tok.Previous->Previous)
       if (Tok.Previous->is(tok::identifier) &&
           Tok.Previous->Previous->is(tok::l_paren))
         return true;
-    }
 
     if (!Tok.Next->Next)
       return false;
 
     // If the next token after the parenthesis is a unary operator, assume
     // that this is cast, unless there are unexpected tokens inside the
     // parenthesis.
     bool NextIsUnary =
         Tok.Next->isUnaryOperator() || Tok.Next->isOneOf(tok::amp, tok::star);
     if (!NextIsUnary || Tok.Next->is(tok::plus) ||
         !Tok.Next->Next->isOneOf(tok::identifier, tok::numeric_constant))
       return false;
     // Search for unexpected tokens.
     for (FormatToken *Prev = Tok.Previous; Prev != Tok.MatchingParen;
-         Prev = Prev->Previous) {
+         Prev = Prev->Previous)
       if (!Prev->isOneOf(tok::kw_const, tok::identifier, tok::coloncolon))
         return false;
-    }
+
     return true;
   }
 
   /// Return the type of the given token assuming it is * or &.
   TokenType determineStarAmpUsage(const FormatToken &Tok, bool IsExpression,
                                   bool InTemplateArgument) {
     if (Style.Language == FormatStyle::LK_JavaScript)
       return TT_BinaryOperator;
while (Current) {
 
       // At the end of the line or when an operator with higher precedence is
       // found, insert fake parenthesis and return.
       if (!Current ||
           (Current->closesScope() &&
            (Current->MatchingParen || Current->is(TT_TemplateString))) ||
           (CurrentPrecedence != -1 && CurrentPrecedence < Precedence) ||
           (CurrentPrecedence == prec::Conditional &&
-           Precedence == prec::Assignment && Current->is(tok::colon))) {
+           Precedence == prec::Assignment && Current->is(tok::colon)))
         break;
-      }
 
       // Consume scopes: (), [], <> and {}
       if (Current->opensScope()) {
         // In fragment of a JavaScript template string can look like '}..${' and
         // thus close a scope and open a new one at the same time.
         while (Current && (!Current->closesScope() || Current->opensScope())) {
           next();
           parse();
while (Current) {
       }
     }
 
     if (LatestOperator && (Current || Precedence > 0)) {
       // LatestOperator->LastOperator = true;
       if (Precedence == PrecedenceArrowAndPeriod) {
         // Call expressions don't have a binary operator precedence.
         addFakeParenthesis(Start, prec::Unknown);
-      } else {
+      } else
         addFakeParenthesis(Start, prec::Level(Precedence));
-      }
-    }
-  }
 
 private:
   /// Gets the precedence (+1) of the given token for binary operators
   /// and other tokens that we treat like binary operators.
   int getCurrentPrecedence() {
     if (Current) {
       const FormatToken *NextNonComment = Current->getNextNonComment();
       if (Current->is(TT_ConditionalExpr))
void parseUnaryOperator() {
     }
     parse(PrecedenceArrowAndPeriod);
     for (FormatToken *Token : llvm::reverse(Tokens))
       // The actual precedence doesn't matter.
       addFakeParenthesis(Token, prec::Unknown);
   }
 
   void parseConditionalExpr() {
-    while (Current && Current->isTrailingComment()) {
+    while (Current && Current->isTrailingComment())
       next();
-    }
+
     FormatToken *Start = Current;
     parse(prec::LogicalOr);
     if (!Current || !Current->is(tok::question))
       return;
     next();
     parse(prec::Assignment);
     if (!Current || Current->isNot(TT_ConditionalExpr))
       return;
for (const FormatToken *Tok = (*I)->First; Tok; Tok = Tok->Next) {
       }
     }
 
     // If the comment is currently aligned with the line immediately following
     // it, that's probably intentional and we should keep it.
     if (NextNonCommentLine && CommentLine &&
         NextNonCommentLine->First->NewlinesBefore <= 1 &&
         NextNonCommentLine->First->OriginalColumn ==
-            (*I)->First->OriginalColumn) {
+            (*I)->First->OriginalColumn)
       // Align comments for preprocessor lines with the # in column 0 if
       // preprocessor lines are not indented. Otherwise, align with the next
       // line.
       (*I)->Level =
           (Style.IndentPPDirectives != FormatStyle::PPDIS_BeforeHash &&
            (NextNonCommentLine->Type == LT_PreprocessorDirective ||
             NextNonCommentLine->Type == LT_ImportStatement))
               ? 0
               : NextNonCommentLine->Level;
-    } else {
+    else
       NextNonCommentLine = (*I)->First->isNot(tok::r_brace) ? (*I) : nullptr;
-    }
 
     setCommentLineLevels((*I)->Children);
   }
 }
 
 static unsigned maxNestingDepth(const AnnotatedLine &Line) {
   unsigned Result = 0;
   for (const auto *Tok = Line.First; Tok != nullptr; Tok = Tok->Next)
     Result = std::max(Result, Tok->NestingLevel);
   return Result;
 }
 
 void TokenAnnotator::annotate(AnnotatedLine &Line) {
   for (SmallVectorImpl<AnnotatedLine *>::iterator I = Line.Children.begin(),
                                                   E = Line.Children.end();
-       I != E; ++I) {
+       I != E; ++I)
     annotate(**I);
-  }
+
   AnnotatingParser Parser(Style, Line, Keywords);
   Line.Type = Parser.parseLine();
 
   // With very deep nesting, ExpressionParser uses lots of stack and the
   // formatting algorithm is very slow. We're not going to do a good job here
   // anyway - it's probably generated code being formatted by mistake.
   // Just skip the whole line.
   if (maxNestingDepth(Line) > 50)
static bool isFunctionDeclarationName(bool IsCpp, const FormatToken &Current,
   if (Current.is(tok::kw_operator)) {
     if (Current.Previous && Current.Previous->is(tok::coloncolon))
       return false;
     Next = skipOperatorName(Next);
   } else {
     if (!Current.is(TT_StartOfName) || Current.NestingLevel != 0)
       return false;
     for (; Next; Next = Next->Next) {
-      if (Next->is(TT_TemplateOpener)) {
+      if (Next->is(TT_TemplateOpener))
         Next = Next->MatchingParen;
-      } else if (Next->is(tok::coloncolon)) {
+      else if (Next->is(tok::coloncolon)) {
         Next = Next->Next;
         if (!Next)
           return false;
         if (Next->is(tok::kw_operator)) {
           Next = skipOperatorName(Next->Next);
           break;
         }
         if (!Next->is(tok::identifier))
           return false;
-      } else if (Next->is(tok::l_paren)) {
+      } else if (Next->is(tok::l_paren))
         break;
-      } else {
+      else
         return false;
-      }
-    }
-  }
 
   // Check whether parameter list can belong to a function declaration.
   if (!Next || !Next->is(tok::l_paren) || !Next->MatchingParen)
     return false;
   // If the lines ends with "{", this is likely a function definition.
   if (Line.Last->is(tok::l_brace))
     return true;
   if (Next->Next == Next->MatchingParen)
bool TokenAnnotator::mustBreakForReturnType(const AnnotatedLine &Line) const {
   }
 
   return false;
 }
 
 void TokenAnnotator::calculateFormattingInformation(AnnotatedLine &Line) {
   for (SmallVectorImpl<AnnotatedLine *>::iterator I = Line.Children.begin(),
                                                   E = Line.Children.end();
-       I != E; ++I) {
+       I != E; ++I)
     calculateFormattingInformation(**I);
-  }
 
   Line.First->TotalLength =
       Line.First->IsMultiline ? Style.ColumnLimit
                               : Line.FirstStartColumn + Line.First->ColumnWidth;
   FormatToken *Current = Line.First->Next;
   bool InFunctionDecl = Line.MightBeFunctionDecl;
   bool AlignArrayOfStructures =
       (Style.AlignArrayOfStructures != FormatStyle::AIAS_None &&
if (Current->is(TT_LineComment)) {
             if (!Parameter->Previous->is(TT_CtorInitializerComma) &&
                 Parameter->HasUnescapedNewline)
               Parameter->MustBreakBefore = true;
             break;
           }
         }
       }
     } else if (Current->SpacesRequiredBefore == 0 &&
-               spaceRequiredBefore(Line, *Current)) {
+               spaceRequiredBefore(Line, *Current))
       Current->SpacesRequiredBefore = 1;
-    }
 
     Current->MustBreakBefore =
         Current->MustBreakBefore || mustBreakBefore(Line, *Current);
 
     if (!Current->MustBreakBefore && InFunctionDecl &&
         Current->is(TT_FunctionDeclarationName))
       Current->MustBreakBefore = mustBreakForReturnType(Line);
 
while (Current) {
 
     // Reduce penalty for aligning ObjC method arguments using the colon
     // alignment as this is the canonical way (still prefer fitting everything
     // into one line if possible). Trying to fit a whole expression into one
     // line should not force other line breaks (e.g. when ObjC method
     // expression is a part of other expression).
     Current->SplitPenalty = splitPenalty(Line, *Current, InFunctionDecl);
     if (Style.Language == FormatStyle::LK_ObjC &&
-        Current->is(TT_SelectorName) && Current->ParameterIndex > 0) {
+        Current->is(TT_SelectorName) && Current->ParameterIndex > 0)
       if (Current->ParameterIndex == 1)
         Current->SplitPenalty += 5 * Current->BindingStrength;
-    } else {
+      else
         Current->SplitPenalty += 20 * Current->BindingStrength;
-    }
 
     Current = Current->Next;
   }
 
   calculateUnbreakableTailLengths(Line);
   unsigned IndentLevel = Line.Level;
   for (Current = Line.First; Current != nullptr; Current = Current->Next) {
     if (Current->Role)

 void TokenAnnotator::calculateUnbreakableTailLengths(AnnotatedLine &Line) {
   unsigned UnbreakableTailLength = 0;
   FormatToken *Current = Line.Last;
   while (Current) {
     Current->UnbreakableTailLength = UnbreakableTailLength;
     if (Current->CanBreakBefore ||
         Current->isOneOf(tok::comment, tok::string_literal)) {
       UnbreakableTailLength = 0;
-    } else {
+    } else
       UnbreakableTailLength +=
           Current->ColumnWidth + Current->SpacesRequiredBefore;
-    }
+
     Current = Current->Previous;
   }
 }
 
 void TokenAnnotator::calculateArrayInitializerColumnList(AnnotatedLine &Line) {
-  if (Line.First == Line.Last) {
+  if (Line.First == Line.Last)
     return;
-  }
+
   auto *CurrentToken = Line.First;
   CurrentToken->ArrayInitializerLineStart = true;
   unsigned Depth = 0;
   while (CurrentToken != nullptr && CurrentToken != Line.Last) {
     if (CurrentToken->is(tok::l_brace)) {
       CurrentToken->IsArrayInitializer = true;
       if (CurrentToken->Next != nullptr)
         CurrentToken->Next->MustBreakBefore = true;
       CurrentToken =
           calculateInitializerColumnList(Line, CurrentToken->Next, Depth + 1);
-    } else {
+    } else
       CurrentToken = CurrentToken->Next;
-    }
-  }
-}
 
 FormatToken *TokenAnnotator::calculateInitializerColumnList(
     AnnotatedLine &Line, FormatToken *CurrentToken, unsigned Depth) {
   while (CurrentToken != nullptr && CurrentToken != Line.Last) {
     if (CurrentToken->is(tok::l_brace))
       ++Depth;
     else if (CurrentToken->is(tok::r_brace))
       --Depth;
if (Left.isOneOf(tok::kw_class, tok::kw_struct))
     return 5000;
   if (Left.is(tok::comment))
     return 1000;
 
   if (Left.isOneOf(TT_RangeBasedForLoopColon, TT_InheritanceColon,
                    TT_CtorInitializerColon))
     return 2;
 
-  if (Right.isMemberAccess()) {
+  if (Right.isMemberAccess())
     // Breaking before the "./->" of a chained call/member access is reasonably
     // cheap, as formatting those with one call per line is generally
     // desirable. In particular, it should be cheaper to break before the call
     // than it is to break inside a call's parameters, which could lead to weird
     // "hanging" indents. The exception is the very last "./->" to support this
     // frequent pattern:
     //
     //   aaaaaaaa.aaaaaaaa.bbbbbbb().ccccccccccccccccccccc(
     //       dddddddd);
     //
     // which might otherwise be blown up onto many lines. Here, clang-format
     // won't produce "hanging" indents anyway as there is no other trailing
     // call.
     //
     // Also apply higher penalty is not a call as that might lead to a wrapping
     // like:
     //
     //   aaaaaaa
     //       .aaaaaaaaa.bbbbbbbb(cccccccc);
     return !Right.NextOperator || !Right.NextOperator->Previous->closesScope()
                ? 150
                : 35;
-  }
 
   if (Right.is(TT_TrailingAnnotation) &&
       (!Right.Next || Right.Next->isNot(tok::l_paren))) {
     // Moving trailing annotations to the next line is fine for ObjC method
     // declarations.
     if (Line.startsWith(TT_ObjCMethodSpecifier))
       return 10;
     // Generally, breaking before a trailing annotation is bad unless it is
if (Left.MatchingParen &&
       return !Style.Cpp11BracedListStyle;
     // A percent is probably part of a formatting specification, such as %lld.
     if (Left.is(tok::percent))
       return false;
     // Preserve the existence of a space before a percent for cases like 0x%04x
     // and "%d %d"
     if (Left.is(tok::numeric_constant) && Right.is(tok::percent))
       return HasExistingWhitespace();
-  } else if (Style.isJson()) {
+  } else if (Style.isJson())
     if (Right.is(tok::colon))
       return false;
-  } else if (Style.isCSharp()) {
+    else if (Style.isCSharp()) {
       // Require spaces around '{' and  before '}' unless they appear in
-    // interpolated strings. Interpolated strings are merged into a single token
-    // so cannot have spaces inserted by this function.
+      // interpolated strings. Interpolated strings are merged into a single
+      // token so cannot have spaces inserted by this function.
 
       // No space between 'this' and '['
       if (Left.is(tok::kw_this) && Right.is(tok::l_square))
         return false;
 
       // No space between 'new' and '('
       if (Left.is(tok::kw_new) && Right.is(tok::l_paren))
         return false;
 
       // Space before { (including space within '{ {').
       if (Right.is(tok::l_brace))
         return true;
 
       // Spaces inside braces.
       if (Left.is(tok::l_brace) && Right.isNot(tok::r_brace))
         return true;
 
       if (Left.isNot(tok::l_brace) && Right.is(tok::r_brace))
         return true;
 
       // Spaces around '=>'.
       if (Left.is(TT_FatArrow) || Right.is(TT_FatArrow))
         return true;
 
       // No spaces around attribute target colons
       if (Left.is(TT_AttributeColon) || Right.is(TT_AttributeColon))
         return false;
 
       // space between type and variable e.g. Dictionary<string,string> foo;
       if (Left.is(TT_TemplateCloser) && Right.is(TT_StartOfName))
         return true;
 
       // spaces inside square brackets.
       if (Left.is(tok::l_square) || Right.is(tok::r_square))
         return Style.SpacesInSquareBrackets;
 
       // No space before ? in nullable types.
       if (Right.is(TT_CSharpNullable))
         return false;
 
       // No space before null forgiving '!'.
       if (Right.is(TT_NonNullAssertion))
         return false;
 
       // No space between consecutive commas '[,,]'.
       if (Left.is(tok::comma) && Right.is(tok::comma))
         return false;
 
       // space after var in `var (key, value)`
       if (Left.is(Keywords.kw_var) && Right.is(tok::l_paren))
         return true;
 
       // space between keywords and paren e.g. "using ("
       if (Right.is(tok::l_paren))
         if (Left.isOneOf(tok::kw_using, Keywords.kw_async, Keywords.kw_when,
                          Keywords.kw_lock))
-        return Style.SpaceBeforeParens == FormatStyle::SBPO_ControlStatements ||
+          return Style.SpaceBeforeParens ==
+                     FormatStyle::SBPO_ControlStatements ||
                  spaceRequiredBeforeParens(Right);
 
       // space between method modifier and opening parenthesis of a tuple return
       // type
       if (Left.isOneOf(tok::kw_public, tok::kw_private, tok::kw_protected,
                        tok::kw_virtual, tok::kw_extern, tok::kw_static,
                        Keywords.kw_internal, Keywords.kw_abstract,
                        Keywords.kw_sealed, Keywords.kw_override,
                        Keywords.kw_async, Keywords.kw_unsafe) &&
           Right.is(tok::l_paren))
         return true;
     } else if (Style.Language == FormatStyle::LK_JavaScript) {
       if (Left.is(TT_FatArrow))
         return true;
       // for await ( ...
-    if (Right.is(tok::l_paren) && Left.is(Keywords.kw_await) && Left.Previous &&
-        Left.Previous->is(tok::kw_for))
+      if (Right.is(tok::l_paren) && Left.is(Keywords.kw_await) &&
+          Left.Previous && Left.Previous->is(tok::kw_for))
         return true;
       if (Left.is(Keywords.kw_async) && Right.is(tok::l_paren) &&
           Right.MatchingParen) {
         const FormatToken *Next = Right.MatchingParen->getNextNonComment();
         // An async arrow function, for example: `x = async () => foo();`,
         // as opposed to calling a function called async: `x = async();`
         if (Next && Next->is(TT_FatArrow))
           return true;
       }
       if ((Left.is(TT_TemplateString) && Left.TokenText.endswith("${")) ||
           (Right.is(TT_TemplateString) && Right.TokenText.startswith("}")))
         return false;
-    // In tagged template literals ("html`bar baz`"), there is no space between
-    // the tag identifier and the template string.
+      // In tagged template literals ("html`bar baz`"), there is no space
+      // between the tag identifier and the template string.
       if (Keywords.IsJavaScriptIdentifier(Left,
                                           /* AcceptIdentifierName= */ false) &&
           Right.is(TT_TemplateString))
         return false;
       if (Right.is(tok::star) &&
           Left.isOneOf(Keywords.kw_function, Keywords.kw_yield))
         return false;
       if (Right.isOneOf(tok::l_brace, tok::l_square) &&
           Left.isOneOf(Keywords.kw_function, Keywords.kw_yield,
                        Keywords.kw_extends, Keywords.kw_implements))
         return true;
       if (Right.is(tok::l_paren)) {
         // JS methods can use some keywords as names (e.g. `delete()`).
         if (Line.MustBeDeclaration && Left.Tok.getIdentifierInfo())
           return false;
         // Valid JS method names can include keywords, e.g. `foo.delete()` or
         // `bar.instanceof()`. Recognize call positions by preceding period.
         if (Left.Previous && Left.Previous->is(tok::period) &&
             Left.Tok.getIdentifierInfo())
           return false;
         // Additional unary JavaScript operators that need a space after.
         if (Left.isOneOf(tok::kw_throw, Keywords.kw_await, Keywords.kw_typeof,
                          tok::kw_void))
           return true;
       }
       // `foo as const;` casts into a const type.
-    if (Left.endsSequence(tok::kw_const, Keywords.kw_as)) {
+      if (Left.endsSequence(tok::kw_const, Keywords.kw_as))
         return false;
-    }
+
       if ((Left.isOneOf(Keywords.kw_let, Keywords.kw_var, Keywords.kw_in,
                         tok::kw_const) ||
            // "of" is only a keyword if it appears after another identifier
            // (e.g. as "const x of y" in a for loop), or after a destructuring
            // operation (const [x, y] of z, const {a, b} of c).
            (Left.is(Keywords.kw_of) && Left.Previous &&
             (Left.Previous->Tok.is(tok::identifier) ||
              Left.Previous->isOneOf(tok::r_square, tok::r_brace)))) &&
           (!Left.Previous || !Left.Previous->is(tok::period)))
         return true;
       if (Left.isOneOf(tok::kw_for, Keywords.kw_as) && Left.Previous &&
           Left.Previous->is(tok::period) && Right.is(tok::l_paren))
         return false;
       if (Left.is(Keywords.kw_as) &&
           Right.isOneOf(tok::l_square, tok::l_brace, tok::l_paren))
         return true;
       if (Left.is(tok::kw_default) && Left.Previous &&
           Left.Previous->is(tok::kw_export))
         return true;
       if (Left.is(Keywords.kw_is) && Right.is(tok::l_brace))
         return true;
       if (Right.isOneOf(TT_JsTypeColon, TT_JsTypeOptionalQuestion))
         return false;
       if (Left.is(TT_JsTypeOperator) || Right.is(TT_JsTypeOperator))
         return false;
       if ((Left.is(tok::l_brace) || Right.is(tok::r_brace)) &&
           Line.First->isOneOf(Keywords.kw_import, tok::kw_export))
         return false;
       if (Left.is(tok::ellipsis))
         return false;
       if (Left.is(TT_TemplateCloser) &&
           !Right.isOneOf(tok::equal, tok::l_brace, tok::comma, tok::l_square,
                          Keywords.kw_implements, Keywords.kw_extends))
         // Type assertions ('<type>expr') are not followed by whitespace. Other
         // locations that should have whitespace following are identified by the
         // above set of follower tokens.
         return false;
       if (Right.is(TT_NonNullAssertion))
         return false;
       if (Left.is(TT_NonNullAssertion) &&
           Right.isOneOf(Keywords.kw_as, Keywords.kw_in))
         return true; // "x! as string", "x! in y"
     } else if (Style.Language == FormatStyle::LK_Java) {
       if (Left.is(tok::r_square) && Right.is(tok::l_brace))
         return true;
       if (Left.is(Keywords.kw_synchronized) && Right.is(tok::l_paren))
         return Style.SpaceBeforeParens != FormatStyle::SBPO_Never;
       if ((Left.isOneOf(tok::kw_static, tok::kw_public, tok::kw_private,
                         tok::kw_protected) ||
            Left.isOneOf(Keywords.kw_final, Keywords.kw_abstract,
                         Keywords.kw_native)) &&
           Right.is(TT_TemplateOpener))
         return true;
     }
   if (Left.is(TT_ImplicitStringLiteral))
     return HasExistingWhitespace();
   if (Line.Type == LT_ObjCMethodDecl) {
     if (Left.is(TT_ObjCMethodSpecifier))
       return true;
     if (Left.is(tok::r_paren) && canBeObjCSelectorComponent(Right))
       // Don't space between ')' and <id> or ')' and 'new'. 'new' is not a
       // keyword in Objective-C, and '+ (instancetype)new;' is a standard class
if (Style.isCSharp()) {
     if (Right.is(tok::r_brace) && Left.is(tok::l_brace) &&
         !Left.Children.empty())
       // Support AllowShortFunctionsOnASingleLine for JavaScript.
       return Style.AllowShortFunctionsOnASingleLine == FormatStyle::SFS_None ||
              Style.AllowShortFunctionsOnASingleLine == FormatStyle::SFS_Empty ||
              (Left.NestingLevel == 0 && Line.Level == 0 &&
               Style.AllowShortFunctionsOnASingleLine &
                   FormatStyle::SFS_InlineOnly);
-  } else if (Style.Language == FormatStyle::LK_Java) {
+  } else if (Style.Language == FormatStyle::LK_Java)
     if (Right.is(tok::plus) && Left.is(tok::string_literal) && Right.Next &&
         Right.Next->is(tok::string_literal))
       return true;
-  } else if (Style.Language == FormatStyle::LK_Cpp ||
+    else if (Style.Language == FormatStyle::LK_Cpp ||
              Style.Language == FormatStyle::LK_ObjC ||
              Style.Language == FormatStyle::LK_Proto ||
              Style.Language == FormatStyle::LK_TableGen ||
-             Style.Language == FormatStyle::LK_TextProto) {
+             Style.Language == FormatStyle::LK_TextProto)
       if (Left.isStringLiteral() && Right.isStringLiteral())
         return true;
-  }
 
   // Basic JSON newline processing.
   if (Style.isJson()) {
     // Always break after a JSON record opener.
     // {
     // }
     if (Left.is(TT_DictLiteral) && Left.is(tok::l_brace))
       return true;
bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line,
   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))) &&
-      Right.NestingLevel == 1 && Style.Language == FormatStyle::LK_Proto) {
+      Right.NestingLevel == 1 && Style.Language == FormatStyle::LK_Proto)
     // Don't put enums or option definitions onto single lines in protocol
     // buffers.
     return true;
-  }
+
   if (Right.is(TT_InlineASMBrace))
     return Right.HasUnescapedNewline;
 
   if (isAllmanBrace(Left) || isAllmanBrace(Right)) {
     auto FirstNonComment = getFirstNonComment(Line);
     bool AccessSpecifier =
         FirstNonComment &&
         FirstNonComment->isOneOf(Keywords.kw_internal, tok::kw_public,
if (Left.is(TT_LambdaLBrace)) {
     if (Style.AllowShortLambdasOnASingleLine == FormatStyle::SLS_None ||
         Style.AllowShortLambdasOnASingleLine == FormatStyle::SLS_Inline ||
         (!Left.Children.empty() &&
          Style.AllowShortLambdasOnASingleLine == FormatStyle::SLS_Empty))
       return true;
   }
 
   if (Style.BraceWrapping.BeforeLambdaBody && Right.is(TT_LambdaLBrace) &&
-      Left.isOneOf(tok::star, tok::amp, tok::ampamp, TT_TemplateCloser)) {
+      Left.isOneOf(tok::star, tok::amp, tok::ampamp, TT_TemplateCloser))
     return true;
-  }
 
   // Put multiple Java annotation on a new line.
   if ((Style.Language == FormatStyle::LK_Java ||
        Style.Language == FormatStyle::LK_JavaScript) &&
       Left.is(TT_LeadingJavaAnnotation) &&
       Right.isNot(TT_LeadingJavaAnnotation) && Right.isNot(tok::l_paren) &&
       (Line.Last->is(tok::l_brace) || Style.BreakAfterJavaFieldAnnotations))
     return true;
if (LBrace &&
         // selector < ... >
         //
         // In case of selector { ... }, the l_brace is TT_DictLiteral.
         // In case of an empty selector {}, the l_brace is not TT_DictLiteral,
         // so we check for immediately following r_brace.
         ((LBrace->is(tok::l_brace) &&
           (LBrace->is(TT_DictLiteral) ||
            (LBrace->Next && LBrace->Next->is(tok::r_brace)))) ||
-         LBrace->is(TT_ArrayInitializerLSquare) || LBrace->is(tok::less))) {
+         LBrace->is(TT_ArrayInitializerLSquare) || LBrace->is(tok::less)))
       // If Left.ParameterCount is 0, then this submessage entry is not the
       // first in its parent submessage, and we want to break before this entry.
       // If Left.ParameterCount is greater than 0, then its parent submessage
       // might contain 1 or more entries and we want to break before this entry
       // if it contains at least 2 entries. We deal with this case later by
       // detecting and breaking before the next entry in the parent submessage.
       if (Left.ParameterCount == 0)
         return true;
-      // However, if this submessage is the first entry in its parent
-      // submessage, Left.ParameterCount might be 1 in some cases.
-      // We deal with this case later by detecting an entry
-      // following a closing paren of this submessage.
-    }
 
     // If this is an entry immediately following a submessage, it will be
     // preceded by a closing paren of that submessage, like in:
     //     left---.  .---right
     //            v  v
     // sub: { ... } key: value
     // If there was a comment between `}` an `key` above, then `key` would be
     // put on a new line anyways.
if (Right.is(Keywords.kw_is)) {
         return false;
     }
     if (Left.is(Keywords.kw_in))
       return Style.BreakBeforeBinaryOperators == FormatStyle::BOS_None;
     if (Right.is(Keywords.kw_in))
       return Style.BreakBeforeBinaryOperators != FormatStyle::BOS_None;
     if (Right.is(Keywords.kw_as))
       return false; // must not break before as in 'x as type' casts
-    if (Right.isOneOf(Keywords.kw_extends, Keywords.kw_infer)) {
+    if (Right.isOneOf(Keywords.kw_extends, Keywords.kw_infer))
       // extends and infer can appear as keywords in conditional types:
       //   https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#conditional-types
       // do not break before them, as the expressions are subject to ASI.
       return false;
-    }
+
     if (Left.is(Keywords.kw_as))
       return true;
     if (Left.is(TT_NonNullAssertion))
       return true;
     if (Left.is(Keywords.kw_declare) &&
         Right.isOneOf(Keywords.kw_module, tok::kw_namespace,
                       Keywords.kw_function, tok::kw_class, tok::kw_enum,
                       Keywords.kw_interface, Keywords.kw_type, Keywords.kw_var,
                       Keywords.kw_let, tok::kw_const))
       // See grammar for 'declare' statements at:
       // https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#A.10
       return false;
     if (Left.isOneOf(Keywords.kw_module, tok::kw_namespace) &&
         Right.isOneOf(tok::identifier, tok::string_literal))
       return false; // must not break in "module foo { ...}"
     if (Right.is(TT_TemplateString) && Right.closesScope())
       return false;
     // Don't split tagged template literal so there is a break between the tag
     // identifier and template string.
-    if (Left.is(tok::identifier) && Right.is(TT_TemplateString)) {
+    if (Left.is(tok::identifier) && Right.is(TT_TemplateString))
       return false;
-    }
+
     if (Left.is(TT_TemplateString) && Left.opensScope())
       return true;
   }
 
   if (Left.is(tok::at))
     return false;
   if (Left.Tok.getObjCKeywordID() == tok::objc_interface)
     return false;