[clang-format] Join spaceRequiredBefore and spaceRequiredBetween

[sstwcw]

Summary

After all these years, having the two functions now serves to confuse
people.

[curdeius]

No objections here, but I need to see other patches to understand where it takes us before accepting.

[HazardyKnusperkeks]

clang/lib/Format/TokenAnnotator.cpp

3069

I'd kept the name spaceRequiredBetween.

[sstwcw]

Use the name spaceRequiredBetween.

[MyDeveloperDay]

This just made a 300 lines function and a 500 line function with minimal comments into a 800 line function.. For no real benefit?

Because from what I can tell you haven't worked on small clang-format issues you won't know that I often put a breakpoint in the spaceRequiredBetween, if it calls out into that function I now know where its covered.

I think if you had fixed a miriade of issues like "I want a space between @ and {" then you would have understood why breaking the 800 lines at least in 2 can be helpful even a little.

I know its not idea, but I'm not sure that the first step I'd make is to join 2 functions to make one massive function, for me my greatest frustration is the lack of comments and the if statements that have about 8 different clauses..

A better developer than me once said "Deal with the case you want and get out"...

[owenpan]

In D121755#3391606, @MyDeveloperDay wrote:

This just made a 300 lines function and a 500 line function with minimal comments into a 800 line function.. For no real benefit?

Because from what I can tell you haven't worked on small clang-format issues you won't know that I often put a breakpoint in the spaceRequiredBetween, if it calls out into that function I now know where its covered.

I think if you had fixed a miriade of issues like "I want a space between @ and {" then you would have understood why breaking the 800 lines at least in 2 can be helpful even a little.

I know its not idea, but I'm not sure that the first step I'd make is to join 2 functions to make one massive function, for me my greatest frustration is the lack of comments and the if statements that have about 8 different clauses..

A better developer than me once said "Deal with the case you want and get out"...

+1.

[sstwcw]

By the way, last time I used a breakpoint on spaceRequiredBefore and stepped until return.

[HazardyKnusperkeks]

FWIW I proposed to go this way: https://discourse.llvm.org/t/clang-format-spacerequiredbefore-vs-spacerequiredbetween/60901/5?u=hazardyknusperkeks

[MyDeveloperDay]

I think you can spin it any number of ways, but bottom line its a massive truth table and I sort of feel however you change it, it will just become a different equally incomprehensible pattern.

For me I'd prefer to stick with the devil I know, unless its broken, but as there are no unit tests my assumption is its not broken.

clang/lib/Format/TokenAnnotator.h

 
 private:
   /// Calculate the penalty for splitting before \c Tok.
   unsigned splitPenalty(const AnnotatedLine &Line, const FormatToken &Tok,
                         bool InFunctionDecl);
 
   bool spaceRequiredBeforeParens(const FormatToken &Right) const;
 
-  bool spaceRequiredBetween(const AnnotatedLine &Line, const FormatToken &Left,
-                            const FormatToken &Right);
-
   bool spaceRequiredBefore(const AnnotatedLine &Line, const FormatToken &Right);
 
   bool mustBreakBefore(const AnnotatedLine &Line, const FormatToken &Right);
 
   bool canBreakBefore(const AnnotatedLine &Line, const FormatToken &Right);
 
   bool mustBreakForReturnType(const AnnotatedLine &Line) const;
 

clang/lib/Format/TokenAnnotator.cpp

if (Right.is(TT_OverloadedOperatorLParen) &&
       Style.SpaceBeforeParensOptions.AfterOverloadedOperator)
     return true;
   if (Style.SpaceBeforeParensOptions.BeforeNonEmptyParentheses &&
       Right.ParameterCount > 0)
     return true;
   return false;
 }
 
-bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
-                                          const FormatToken &Left,
-                                          const FormatToken &Right) {
-  if (Left.is(tok::kw_return) &&
-      !Right.isOneOf(tok::semi, tok::r_paren, tok::hashhash))
-    return true;
-  if (Style.isJson() && Left.is(tok::string_literal) && Right.is(tok::colon))
-    return false;
-  if (Left.is(Keywords.kw_assert) && Style.Language == FormatStyle::LK_Java)
-    return true;
-  if (Style.ObjCSpaceAfterProperty && Line.Type == LT_ObjCProperty &&
-      Left.Tok.getObjCKeywordID() == tok::objc_property)
-    return true;
-  if (Right.is(tok::hashhash))
-    return Left.is(tok::hash);
-  if (Left.isOneOf(tok::hashhash, tok::hash))
-    return Right.is(tok::hash);
-  if ((Left.is(tok::l_paren) && Right.is(tok::r_paren)) ||
-      (Left.is(tok::l_brace) && Left.isNot(BK_Block) &&
-       Right.is(tok::r_brace) && Right.isNot(BK_Block)))
-    return Style.SpaceInEmptyParentheses;
-  if (Style.SpacesInConditionalStatement) {
-    if (Left.is(tok::l_paren) && Left.Previous &&
-        isKeywordWithCondition(*Left.Previous))
-      return true;
-    if (Right.is(tok::r_paren) && Right.MatchingParen &&
-        Right.MatchingParen->Previous &&
-        isKeywordWithCondition(*Right.MatchingParen->Previous))
-      return true;
-  }
-
-  // auto{x} auto(x)
-  if (Left.is(tok::kw_auto) && Right.isOneOf(tok::l_paren, tok::l_brace))
-    return false;
-
-  // operator co_await(x)
-  if (Right.is(tok::l_paren) && Left.is(tok::kw_co_await) && Left.Previous &&
-      Left.Previous->is(tok::kw_operator))
-    return false;
-  // co_await (x), co_yield (x), co_return (x)
-  if (Left.isOneOf(tok::kw_co_await, tok::kw_co_yield, tok::kw_co_return) &&
-      !Right.isOneOf(tok::semi, tok::r_paren))
-    return true;
-
-  if (Left.is(tok::l_paren) || Right.is(tok::r_paren))
-    return (Right.is(TT_CastRParen) ||
-            (Left.MatchingParen && Left.MatchingParen->is(TT_CastRParen)))
-               ? Style.SpacesInCStyleCastParentheses
-               : Style.SpacesInParentheses;
-  if (Right.isOneOf(tok::semi, tok::comma))
-    return false;
-  if (Right.is(tok::less) && Line.Type == LT_ObjCDecl) {
-    bool IsLightweightGeneric = Right.MatchingParen &&
-                                Right.MatchingParen->Next &&
-                                Right.MatchingParen->Next->is(tok::colon);
-    return !IsLightweightGeneric && Style.ObjCSpaceBeforeProtocolList;
-  }
-  if (Right.is(tok::less) && Left.is(tok::kw_template))
-    return Style.SpaceAfterTemplateKeyword;
-  if (Left.isOneOf(tok::exclaim, tok::tilde))
-    return false;
-  if (Left.is(tok::at) &&
-      Right.isOneOf(tok::identifier, tok::string_literal, tok::char_constant,
-                    tok::numeric_constant, tok::l_paren, tok::l_brace,
-                    tok::kw_true, tok::kw_false))
-    return false;
-  if (Left.is(tok::colon))
-    return !Left.is(TT_ObjCMethodExpr);
-  if (Left.is(tok::coloncolon))
-    return false;
-  if (Left.is(tok::less) || Right.isOneOf(tok::greater, tok::less)) {
-    if (Style.Language == FormatStyle::LK_TextProto ||
-        (Style.Language == FormatStyle::LK_Proto &&
-         (Left.is(TT_DictLiteral) || Right.is(TT_DictLiteral)))) {
-      // Format empty list as `<>`.
-      if (Left.is(tok::less) && Right.is(tok::greater))
-        return false;
-      return !Style.Cpp11BracedListStyle;
-    }
-    return false;
-  }
-  if (Right.is(tok::ellipsis))
-    return Left.Tok.isLiteral() || (Left.is(tok::identifier) && Left.Previous &&
-                                    Left.Previous->is(tok::kw_case));
-  if (Left.is(tok::l_square) && Right.is(tok::amp))
-    return Style.SpacesInSquareBrackets;
-  if (Right.is(TT_PointerOrReference)) {
-    if (Left.is(tok::r_paren) && Line.MightBeFunctionDecl) {
-      if (!Left.MatchingParen)
-        return true;
-      FormatToken *TokenBeforeMatchingParen =
-          Left.MatchingParen->getPreviousNonComment();
-      if (!TokenBeforeMatchingParen || !Left.is(TT_TypeDeclarationParen))
-        return true;
-    }
-    // Add a space if the previous token is a pointer qualifier or the closing
-    // parenthesis of __attribute__(()) expression and the style requires spaces
-    // after pointer qualifiers.
-    if ((Style.SpaceAroundPointerQualifiers == FormatStyle::SAPQ_After ||
-         Style.SpaceAroundPointerQualifiers == FormatStyle::SAPQ_Both) &&
-        (Left.is(TT_AttributeParen) || Left.canBePointerOrReferenceQualifier()))
-      return true;
-    if (Left.Tok.isLiteral())
-      return true;
-    // for (auto a = 0, b = 0; const auto & c : {1, 2, 3})
-    if (Left.isTypeOrIdentifier() && Right.Next && Right.Next->Next &&
-        Right.Next->Next->is(TT_RangeBasedForLoopColon))
-      return getTokenPointerOrReferenceAlignment(Right) !=
-             FormatStyle::PAS_Left;
-    return !Left.isOneOf(TT_PointerOrReference, tok::l_paren) &&
-           (getTokenPointerOrReferenceAlignment(Right) !=
-                FormatStyle::PAS_Left ||
-            (Line.IsMultiVariableDeclStmt &&
-             (Left.NestingLevel == 0 ||
-              (Left.NestingLevel == 1 && startsWithInitStatement(Line)))));
-  }
-  if (Right.is(TT_FunctionTypeLParen) && Left.isNot(tok::l_paren) &&
-      (!Left.is(TT_PointerOrReference) ||
-       (getTokenPointerOrReferenceAlignment(Left) != FormatStyle::PAS_Right &&
-        !Line.IsMultiVariableDeclStmt)))
-    return true;
-  if (Left.is(TT_PointerOrReference)) {
-    // Add a space if the next token is a pointer qualifier and the style
-    // requires spaces before pointer qualifiers.
-    if ((Style.SpaceAroundPointerQualifiers == FormatStyle::SAPQ_Before ||
-         Style.SpaceAroundPointerQualifiers == FormatStyle::SAPQ_Both) &&
-        Right.canBePointerOrReferenceQualifier())
-      return true;
-    // & 1
-    if (Right.Tok.isLiteral())
-      return true;
-    // & /* comment
-    if (Right.is(TT_BlockComment))
-      return true;
-    // foo() -> const Bar * override/final
-    if (Right.isOneOf(Keywords.kw_override, Keywords.kw_final) &&
-        !Right.is(TT_StartOfName))
-      return true;
-    // & {
-    if (Right.is(tok::l_brace) && Right.is(BK_Block))
-      return true;
-    // for (auto a = 0, b = 0; const auto& c : {1, 2, 3})
-    if (Left.Previous && Left.Previous->isTypeOrIdentifier() && Right.Next &&
-        Right.Next->is(TT_RangeBasedForLoopColon))
-      return getTokenPointerOrReferenceAlignment(Left) !=
-             FormatStyle::PAS_Right;
-    if (Right.isOneOf(TT_PointerOrReference, TT_ArraySubscriptLSquare,
-                      tok::l_paren))
-      return false;
-    if (getTokenPointerOrReferenceAlignment(Left) == FormatStyle::PAS_Right)
-      return false;
-    // FIXME: Setting IsMultiVariableDeclStmt for the whole line is error-prone,
-    // because it does not take into account nested scopes like lambdas.
-    // In multi-variable declaration statements, attach */& to the variable
-    // independently of the style. However, avoid doing it if we are in a nested
-    // scope, e.g. lambda. We still need to special-case statements with
-    // initializers.
-    if (Line.IsMultiVariableDeclStmt &&
-        (Left.NestingLevel == Line.First->NestingLevel ||
-         ((Left.NestingLevel == Line.First->NestingLevel + 1) &&
-          startsWithInitStatement(Line))))
-      return false;
-    return Left.Previous && !Left.Previous->isOneOf(
-                                tok::l_paren, tok::coloncolon, tok::l_square);
-  }
-  // Ensure right pointer alignment with ellipsis e.g. int *...P
-  if (Left.is(tok::ellipsis) && Left.Previous &&
-      Left.Previous->isOneOf(tok::star, tok::amp, tok::ampamp))
-    return Style.PointerAlignment != FormatStyle::PAS_Right;
-
-  if (Right.is(tok::star) && Left.is(tok::l_paren))
-    return false;
-  if (Left.is(tok::star) && Right.isOneOf(tok::star, tok::amp, tok::ampamp))
-    return false;
-  if (Right.isOneOf(tok::star, tok::amp, tok::ampamp)) {
-    const FormatToken *Previous = &Left;
-    while (Previous && !Previous->is(tok::kw_operator)) {
-      if (Previous->is(tok::identifier) || Previous->isSimpleTypeSpecifier()) {
-        Previous = Previous->getPreviousNonComment();
-        continue;
-      }
-      if (Previous->is(TT_TemplateCloser) && Previous->MatchingParen) {
-        Previous = Previous->MatchingParen->getPreviousNonComment();
-        continue;
-      }
-      if (Previous->is(tok::coloncolon)) {
-        Previous = Previous->getPreviousNonComment();
-        continue;
-      }
-      break;
-    }
-    // Space between the type and the * in:
-    //   operator void*()
-    //   operator char*()
-    //   operator void const*()
-    //   operator void volatile*()
-    //   operator /*comment*/ const char*()
-    //   operator volatile /*comment*/ char*()
-    //   operator Foo*()
-    //   operator C<T>*()
-    //   operator std::Foo*()
-    //   operator C<T>::D<U>*()
-    // dependent on PointerAlignment style.
-    if (Previous) {
-      if (Previous->endsSequence(tok::kw_operator))
-        return Style.PointerAlignment != FormatStyle::PAS_Left;
-      if (Previous->is(tok::kw_const) || Previous->is(tok::kw_volatile))
-        return (Style.PointerAlignment != FormatStyle::PAS_Left) ||
-               (Style.SpaceAroundPointerQualifiers ==
-                FormatStyle::SAPQ_After) ||
-               (Style.SpaceAroundPointerQualifiers == FormatStyle::SAPQ_Both);
-    }
-  }
-  const auto SpaceRequiredForArrayInitializerLSquare =
-      [](const FormatToken &LSquareTok, const FormatStyle &Style) {
-        return Style.SpacesInContainerLiterals ||
-               ((Style.Language == FormatStyle::LK_Proto ||
-                 Style.Language == FormatStyle::LK_TextProto) &&
-                !Style.Cpp11BracedListStyle &&
-                LSquareTok.endsSequence(tok::l_square, tok::colon,
-                                        TT_SelectorName));
-      };
-  if (Left.is(tok::l_square))
-    return (Left.is(TT_ArrayInitializerLSquare) && Right.isNot(tok::r_square) &&
-            SpaceRequiredForArrayInitializerLSquare(Left, Style)) ||
-           (Left.isOneOf(TT_ArraySubscriptLSquare, TT_StructuredBindingLSquare,
-                         TT_LambdaLSquare) &&
-            Style.SpacesInSquareBrackets && Right.isNot(tok::r_square));
-  if (Right.is(tok::r_square))
-    return Right.MatchingParen &&
-           ((Right.MatchingParen->is(TT_ArrayInitializerLSquare) &&
-             SpaceRequiredForArrayInitializerLSquare(*Right.MatchingParen,
-                                                     Style)) ||
-            (Style.SpacesInSquareBrackets &&
-             Right.MatchingParen->isOneOf(TT_ArraySubscriptLSquare,
-                                          TT_StructuredBindingLSquare,
-                                          TT_LambdaLSquare)) ||
-            Right.MatchingParen->is(TT_AttributeParen));
-  if (Right.is(tok::l_square) &&
-      !Right.isOneOf(TT_ObjCMethodExpr, TT_LambdaLSquare,
-                     TT_DesignatedInitializerLSquare,
-                     TT_StructuredBindingLSquare, TT_AttributeSquare) &&
-      !Left.isOneOf(tok::numeric_constant, TT_DictLiteral) &&
-      !(!Left.is(tok::r_square) && Style.SpaceBeforeSquareBrackets &&
-        Right.is(TT_ArraySubscriptLSquare)))
-    return false;
-  if (Left.is(tok::l_brace) && Right.is(tok::r_brace))
-    return !Left.Children.empty(); // No spaces in "{}".
-  if ((Left.is(tok::l_brace) && Left.isNot(BK_Block)) ||
-      (Right.is(tok::r_brace) && Right.MatchingParen &&
-       Right.MatchingParen->isNot(BK_Block)))
-    return Style.Cpp11BracedListStyle ? Style.SpacesInParentheses : true;
-  if (Left.is(TT_BlockComment))
-    // No whitespace in x(/*foo=*/1), except for JavaScript.
-    return Style.isJavaScript() || !Left.TokenText.endswith("=*/");
-
-  // Space between template and attribute.
-  // e.g. template <typename T> [[nodiscard]] ...
-  if (Left.is(TT_TemplateCloser) && Right.is(TT_AttributeSquare))
-    return true;
-  // Space before parentheses common for all languages
-  if (Right.is(tok::l_paren)) {
-    if (Left.is(TT_TemplateCloser) && Right.isNot(TT_FunctionTypeLParen))
-      return spaceRequiredBeforeParens(Right);
-    if (Left.isOneOf(TT_RequiresClause, TT_RequiresClauseInARequiresExpression))
-      return Style.SpaceBeforeParensOptions.AfterRequiresInClause ||
-             spaceRequiredBeforeParens(Right);
-    if (Left.is(TT_RequiresExpression))
-      return Style.SpaceBeforeParensOptions.AfterRequiresInExpression ||
-             spaceRequiredBeforeParens(Right);
-    if ((Left.is(tok::r_paren) && Left.is(TT_AttributeParen)) ||
-        (Left.is(tok::r_square) && Left.is(TT_AttributeSquare)))
-      return true;
-    if (Left.is(TT_ForEachMacro))
-      return Style.SpaceBeforeParensOptions.AfterForeachMacros ||
-             spaceRequiredBeforeParens(Right);
-    if (Left.is(TT_IfMacro))
-      return Style.SpaceBeforeParensOptions.AfterIfMacros ||
-             spaceRequiredBeforeParens(Right);
-    if (Line.Type == LT_ObjCDecl)
-      return true;
-    if (Left.is(tok::semi))
-      return true;
-    if (Left.isOneOf(tok::pp_elif, tok::kw_for, tok::kw_while, tok::kw_switch,
-                     tok::kw_case, TT_ForEachMacro, TT_ObjCForIn))
-      return Style.SpaceBeforeParensOptions.AfterControlStatements ||
-             spaceRequiredBeforeParens(Right);
-    if (Left.isIf(Line.Type != LT_PreprocessorDirective))
-      return Style.SpaceBeforeParensOptions.AfterControlStatements ||
-             spaceRequiredBeforeParens(Right);
-
-    // TODO add Operator overloading specific Options to
-    // SpaceBeforeParensOptions
-    if (Right.is(TT_OverloadedOperatorLParen))
-      return spaceRequiredBeforeParens(Right);
-    // Function declaration or definition
-    if (Line.MightBeFunctionDecl && (Left.is(TT_FunctionDeclarationName))) {
-      if (Line.mightBeFunctionDefinition())
-        return Style.SpaceBeforeParensOptions.AfterFunctionDefinitionName ||
-               spaceRequiredBeforeParens(Right);
-      else
-        return Style.SpaceBeforeParensOptions.AfterFunctionDeclarationName ||
-               spaceRequiredBeforeParens(Right);
-    }
-    // Lambda
-    if (Line.Type != LT_PreprocessorDirective && Left.is(tok::r_square) &&
-        Left.MatchingParen && Left.MatchingParen->is(TT_LambdaLSquare))
-      return Style.SpaceBeforeParensOptions.AfterFunctionDefinitionName ||
-             spaceRequiredBeforeParens(Right);
-    if (!Left.Previous || Left.Previous->isNot(tok::period)) {
-      if (Left.isOneOf(tok::kw_try, Keywords.kw___except, tok::kw_catch))
-        return Style.SpaceBeforeParensOptions.AfterControlStatements ||
-               spaceRequiredBeforeParens(Right);
-      if (Left.isOneOf(tok::kw_new, tok::kw_delete))
-        return ((!Line.MightBeFunctionDecl || !Left.Previous) &&
-                Style.SpaceBeforeParens != FormatStyle::SBPO_Never) ||
-               spaceRequiredBeforeParens(Right);
-
-      if (Left.is(tok::r_square) && Left.MatchingParen &&
-          Left.MatchingParen->Previous &&
-          Left.MatchingParen->Previous->is(tok::kw_delete))
-        return (Style.SpaceBeforeParens != FormatStyle::SBPO_Never) ||
-               spaceRequiredBeforeParens(Right);
-    }
-    if (Line.Type != LT_PreprocessorDirective &&
-        (Left.is(tok::identifier) || Left.isFunctionLikeKeyword() ||
-         Left.is(tok::r_paren) || Left.isSimpleTypeSpecifier()))
-      return spaceRequiredBeforeParens(Right);
-    return false;
-  }
-  if (Left.is(tok::at) && Right.Tok.getObjCKeywordID() != tok::objc_not_keyword)
-    return false;
-  if (Right.is(TT_UnaryOperator))
-    return !Left.isOneOf(tok::l_paren, tok::l_square, tok::at) &&
-           (Left.isNot(tok::colon) || Left.isNot(TT_ObjCMethodExpr));
-  if ((Left.isOneOf(tok::identifier, tok::greater, tok::r_square,
-                    tok::r_paren) ||
-       Left.isSimpleTypeSpecifier()) &&
-      Right.is(tok::l_brace) && Right.getNextNonComment() &&
-      Right.isNot(BK_Block))
-    return false;
-  if (Left.is(tok::period) || Right.is(tok::period))
-    return false;
-  // u#str, U#str, L#str, u8#str
-  // uR#str, UR#str, LR#str, u8R#str
-  if (Right.is(tok::hash) && Left.is(tok::identifier) &&
-      (Left.TokenText == "L" || Left.TokenText == "u" ||
-       Left.TokenText == "U" || Left.TokenText == "u8" ||
-       Left.TokenText == "LR" || Left.TokenText == "uR" ||
-       Left.TokenText == "UR" || Left.TokenText == "u8R"))
-    return false;
-  if (Left.is(TT_TemplateCloser) && Left.MatchingParen &&
-      Left.MatchingParen->Previous &&
-      (Left.MatchingParen->Previous->is(tok::period) ||
-       Left.MatchingParen->Previous->is(tok::coloncolon)))
-    // Java call to generic function with explicit type:
-    // A.<B<C<...>>>DoSomething();
-    // A::<B<C<...>>>DoSomething();  // With a Java 8 method reference.
-    return false;
-  if (Left.is(TT_TemplateCloser) && Right.is(tok::l_square))
-    return false;
-  if (Left.is(tok::l_brace) && Left.endsSequence(TT_DictLiteral, tok::at))
-    // Objective-C dictionary literal -> no space after opening brace.
-    return false;
-  if (Right.is(tok::r_brace) && Right.MatchingParen &&
-      Right.MatchingParen->endsSequence(TT_DictLiteral, tok::at))
-    // Objective-C dictionary literal -> no space before closing brace.
-    return false;
-  if (Right.getType() == TT_TrailingAnnotation &&
-      Right.isOneOf(tok::amp, tok::ampamp) &&
-      Left.isOneOf(tok::kw_const, tok::kw_volatile) &&
-      (!Right.Next || Right.Next->is(tok::semi)))
-    // Match const and volatile ref-qualifiers without any additional
-    // qualifiers such as
-    // void Fn() const &;
-    return getTokenReferenceAlignment(Right) != FormatStyle::PAS_Left;
-
-  return true;
-}
-
 bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line,
                                          const FormatToken &Right) {
+  assert(Right.Previous);
   const FormatToken &Left = *Right.Previous;
 
   // If the token is finalized don't touch it (as it could be in a
   // clang-format-off section).
   if (Left.Finalized)
     return Right.hasWhitespaceBefore();
 
   if (Right.Tok.getIdentifierInfo() && Left.Tok.getIdentifierInfo())
if (Right.is(TT_TemplateOpener) && Left.is(tok::r_paren) &&
     return false;
   if (Right.is(tok::less) && Left.isNot(tok::l_paren) &&
       Line.startsWith(tok::hash))
     return true;
   if (Right.is(TT_TrailingUnaryOperator))
     return false;
   if (Left.is(TT_RegexLiteral))
     return false;
-  return spaceRequiredBetween(Line, Left, Right);
+
+  if (Left.is(tok::kw_return) &&
+      !Right.isOneOf(tok::semi, tok::r_paren, tok::hashhash))
+    return true;
+  if (Style.isJson() && Left.is(tok::string_literal) && Right.is(tok::colon))
+    return false;
+  if (Left.is(Keywords.kw_assert) && Style.Language == FormatStyle::LK_Java)
+    return true;
+  if (Style.ObjCSpaceAfterProperty && Line.Type == LT_ObjCProperty &&
+      Left.Tok.getObjCKeywordID() == tok::objc_property)
+    return true;
+  if (Right.is(tok::hashhash))
+    return Left.is(tok::hash);
+  if (Left.isOneOf(tok::hashhash, tok::hash))
+    return Right.is(tok::hash);
+  if ((Left.is(tok::l_paren) && Right.is(tok::r_paren)) ||
+      (Left.is(tok::l_brace) && Left.isNot(BK_Block) &&
+       Right.is(tok::r_brace) && Right.isNot(BK_Block)))
+    return Style.SpaceInEmptyParentheses;
+  if (Style.SpacesInConditionalStatement) {
+    if (Left.is(tok::l_paren) && Left.Previous &&
+        isKeywordWithCondition(*Left.Previous))
+      return true;
+    if (Right.is(tok::r_paren) && Right.MatchingParen &&
+        Right.MatchingParen->Previous &&
+        isKeywordWithCondition(*Right.MatchingParen->Previous))
+      return true;
+  }
+
+  // auto{x} auto(x)
+  if (Left.is(tok::kw_auto) && Right.isOneOf(tok::l_paren, tok::l_brace))
+    return false;
+
+  // operator co_await(x)
+  if (Right.is(tok::l_paren) && Left.is(tok::kw_co_await) && Left.Previous &&
+      Left.Previous->is(tok::kw_operator))
+    return false;
+  // co_await (x), co_yield (x), co_return (x)
+  if (Left.isOneOf(tok::kw_co_await, tok::kw_co_yield, tok::kw_co_return) &&
+      !Right.isOneOf(tok::semi, tok::r_paren))
+    return true;
+
+  if (Left.is(tok::l_paren) || Right.is(tok::r_paren))
+    return (Right.is(TT_CastRParen) ||
+            (Left.MatchingParen && Left.MatchingParen->is(TT_CastRParen)))
+               ? Style.SpacesInCStyleCastParentheses
+               : Style.SpacesInParentheses;
+  if (Right.isOneOf(tok::semi, tok::comma))
+    return false;
+  if (Right.is(tok::less) && Line.Type == LT_ObjCDecl) {
+    bool IsLightweightGeneric = Right.MatchingParen &&
+                                Right.MatchingParen->Next &&
+                                Right.MatchingParen->Next->is(tok::colon);
+    return !IsLightweightGeneric && Style.ObjCSpaceBeforeProtocolList;
+  }
+  if (Right.is(tok::less) && Left.is(tok::kw_template))
+    return Style.SpaceAfterTemplateKeyword;
+  if (Left.isOneOf(tok::exclaim, tok::tilde))
+    return false;
+  if (Left.is(tok::at) &&
+      Right.isOneOf(tok::identifier, tok::string_literal, tok::char_constant,
+                    tok::numeric_constant, tok::l_paren, tok::l_brace,
+                    tok::kw_true, tok::kw_false))
+    return false;
+  if (Left.is(tok::colon))
+    return !Left.is(TT_ObjCMethodExpr);
+  if (Left.is(tok::coloncolon))
+    return false;
+  if (Left.is(tok::less) || Right.isOneOf(tok::greater, tok::less)) {
+    if (Style.Language == FormatStyle::LK_TextProto ||
+        (Style.Language == FormatStyle::LK_Proto &&
+         (Left.is(TT_DictLiteral) || Right.is(TT_DictLiteral)))) {
+      // Format empty list as `<>`.
+      if (Left.is(tok::less) && Right.is(tok::greater))
+        return false;
+      return !Style.Cpp11BracedListStyle;
+    }
+    return false;
+  }
+  if (Right.is(tok::ellipsis))
+    return Left.Tok.isLiteral() || (Left.is(tok::identifier) && Left.Previous &&
+                                    Left.Previous->is(tok::kw_case));
+  if (Left.is(tok::l_square) && Right.is(tok::amp))
+    return Style.SpacesInSquareBrackets;
+  if (Right.is(TT_PointerOrReference)) {
+    if (Left.is(tok::r_paren) && Line.MightBeFunctionDecl) {
+      if (!Left.MatchingParen)
+        return true;
+      FormatToken *TokenBeforeMatchingParen =
+          Left.MatchingParen->getPreviousNonComment();
+      if (!TokenBeforeMatchingParen || !Left.is(TT_TypeDeclarationParen))
+        return true;
+    }
+    // Add a space if the previous token is a pointer qualifier or the closing
+    // parenthesis of __attribute__(()) expression and the style requires spaces
+    // after pointer qualifiers.
+    if ((Style.SpaceAroundPointerQualifiers == FormatStyle::SAPQ_After ||
+         Style.SpaceAroundPointerQualifiers == FormatStyle::SAPQ_Both) &&
+        (Left.is(TT_AttributeParen) || Left.canBePointerOrReferenceQualifier()))
+      return true;
+    if (Left.Tok.isLiteral())
+      return true;
+    // for (auto a = 0, b = 0; const auto & c : {1, 2, 3})
+    if (Left.isTypeOrIdentifier() && Right.Next && Right.Next->Next &&
+        Right.Next->Next->is(TT_RangeBasedForLoopColon))
+      return getTokenPointerOrReferenceAlignment(Right) !=
+             FormatStyle::PAS_Left;
+    return !Left.isOneOf(TT_PointerOrReference, tok::l_paren) &&
+           (getTokenPointerOrReferenceAlignment(Right) !=
+                FormatStyle::PAS_Left ||
+            (Line.IsMultiVariableDeclStmt &&
+             (Left.NestingLevel == 0 ||
+              (Left.NestingLevel == 1 && startsWithInitStatement(Line)))));
+  }
+  if (Right.is(TT_FunctionTypeLParen) && Left.isNot(tok::l_paren) &&
+      (!Left.is(TT_PointerOrReference) ||
+       (getTokenPointerOrReferenceAlignment(Left) != FormatStyle::PAS_Right &&
+        !Line.IsMultiVariableDeclStmt)))
+    return true;
+  if (Left.is(TT_PointerOrReference)) {
+    // Add a space if the next token is a pointer qualifier and the style
+    // requires spaces before pointer qualifiers.
+    if ((Style.SpaceAroundPointerQualifiers == FormatStyle::SAPQ_Before ||
+         Style.SpaceAroundPointerQualifiers == FormatStyle::SAPQ_Both) &&
+        Right.canBePointerOrReferenceQualifier())
+      return true;
+    // & 1
+    if (Right.Tok.isLiteral())
+      return true;
+    // & /* comment
+    if (Right.is(TT_BlockComment))
+      return true;
+    // foo() -> const Bar * override/final
+    if (Right.isOneOf(Keywords.kw_override, Keywords.kw_final) &&
+        !Right.is(TT_StartOfName))
+      return true;
+    // & {
+    if (Right.is(tok::l_brace) && Right.is(BK_Block))
+      return true;
+    // for (auto a = 0, b = 0; const auto& c : {1, 2, 3})
+    if (Left.Previous && Left.Previous->isTypeOrIdentifier() && Right.Next &&
+        Right.Next->is(TT_RangeBasedForLoopColon))
+      return getTokenPointerOrReferenceAlignment(Left) !=
+             FormatStyle::PAS_Right;
+    if (Right.isOneOf(TT_PointerOrReference, TT_ArraySubscriptLSquare,
+                      tok::l_paren))
+      return false;
+    if (getTokenPointerOrReferenceAlignment(Left) == FormatStyle::PAS_Right)
+      return false;
+    // FIXME: Setting IsMultiVariableDeclStmt for the whole line is error-prone,
+    // because it does not take into account nested scopes like lambdas.
+    // In multi-variable declaration statements, attach */& to the variable
+    // independently of the style. However, avoid doing it if we are in a nested
+    // scope, e.g. lambda. We still need to special-case statements with
+    // initializers.
+    if (Line.IsMultiVariableDeclStmt &&
+        (Left.NestingLevel == Line.First->NestingLevel ||
+         ((Left.NestingLevel == Line.First->NestingLevel + 1) &&
+          startsWithInitStatement(Line))))
+      return false;
+    return Left.Previous && !Left.Previous->isOneOf(
+                                tok::l_paren, tok::coloncolon, tok::l_square);
+  }
+  // Ensure right pointer alignment with ellipsis e.g. int *...P
+  if (Left.is(tok::ellipsis) && Left.Previous &&
+      Left.Previous->isOneOf(tok::star, tok::amp, tok::ampamp))
+    return Style.PointerAlignment != FormatStyle::PAS_Right;
+
+  if (Right.is(tok::star) && Left.is(tok::l_paren))
+    return false;
+  if (Left.is(tok::star) && Right.isOneOf(tok::star, tok::amp, tok::ampamp))
+    return false;
+  if (Right.isOneOf(tok::star, tok::amp, tok::ampamp)) {
+    const FormatToken *Previous = &Left;
+    while (Previous && !Previous->is(tok::kw_operator)) {
+      if (Previous->is(tok::identifier) || Previous->isSimpleTypeSpecifier()) {
+        Previous = Previous->getPreviousNonComment();
+        continue;
+      }
+      if (Previous->is(TT_TemplateCloser) && Previous->MatchingParen) {
+        Previous = Previous->MatchingParen->getPreviousNonComment();
+        continue;
+      }
+      if (Previous->is(tok::coloncolon)) {
+        Previous = Previous->getPreviousNonComment();
+        continue;
+      }
+      break;
+    }
+    // Space between the type and the * in:
+    //   operator void*()
+    //   operator char*()
+    //   operator void const*()
+    //   operator void volatile*()
+    //   operator /*comment*/ const char*()
+    //   operator volatile /*comment*/ char*()
+    //   operator Foo*()
+    //   operator C<T>*()
+    //   operator std::Foo*()
+    //   operator C<T>::D<U>*()
+    // dependent on PointerAlignment style.
+    if (Previous) {
+      if (Previous->endsSequence(tok::kw_operator))
+        return Style.PointerAlignment != FormatStyle::PAS_Left;
+      if (Previous->is(tok::kw_const) || Previous->is(tok::kw_volatile))
+        return (Style.PointerAlignment != FormatStyle::PAS_Left) ||
+               (Style.SpaceAroundPointerQualifiers ==
+                FormatStyle::SAPQ_After) ||
+               (Style.SpaceAroundPointerQualifiers == FormatStyle::SAPQ_Both);
+    }
+  }
+  const auto SpaceRequiredForArrayInitializerLSquare =
+      [](const FormatToken &LSquareTok, const FormatStyle &Style) {
+        return Style.SpacesInContainerLiterals ||
+               ((Style.Language == FormatStyle::LK_Proto ||
+                 Style.Language == FormatStyle::LK_TextProto) &&
+                !Style.Cpp11BracedListStyle &&
+                LSquareTok.endsSequence(tok::l_square, tok::colon,
+                                        TT_SelectorName));
+      };
+  if (Left.is(tok::l_square))
+    return (Left.is(TT_ArrayInitializerLSquare) && Right.isNot(tok::r_square) &&
+            SpaceRequiredForArrayInitializerLSquare(Left, Style)) ||
+           (Left.isOneOf(TT_ArraySubscriptLSquare, TT_StructuredBindingLSquare,
+                         TT_LambdaLSquare) &&
+            Style.SpacesInSquareBrackets && Right.isNot(tok::r_square));
+  if (Right.is(tok::r_square))
+    return Right.MatchingParen &&
+           ((Right.MatchingParen->is(TT_ArrayInitializerLSquare) &&
+             SpaceRequiredForArrayInitializerLSquare(*Right.MatchingParen,
+                                                     Style)) ||
+            (Style.SpacesInSquareBrackets &&
+             Right.MatchingParen->isOneOf(TT_ArraySubscriptLSquare,
+                                          TT_StructuredBindingLSquare,
+                                          TT_LambdaLSquare)) ||
+            Right.MatchingParen->is(TT_AttributeParen));
+  if (Right.is(tok::l_square) &&
+      !Right.isOneOf(TT_ObjCMethodExpr, TT_LambdaLSquare,
+                     TT_DesignatedInitializerLSquare,
+                     TT_StructuredBindingLSquare, TT_AttributeSquare) &&
+      !Left.isOneOf(tok::numeric_constant, TT_DictLiteral) &&
+      !(!Left.is(tok::r_square) && Style.SpaceBeforeSquareBrackets &&
+        Right.is(TT_ArraySubscriptLSquare)))
+    return false;
+  if (Left.is(tok::l_brace) && Right.is(tok::r_brace))
+    return !Left.Children.empty(); // No spaces in "{}".
+  if ((Left.is(tok::l_brace) && Left.isNot(BK_Block)) ||
+      (Right.is(tok::r_brace) && Right.MatchingParen &&
+       Right.MatchingParen->isNot(BK_Block)))
+    return Style.Cpp11BracedListStyle ? Style.SpacesInParentheses : true;
+  if (Left.is(TT_BlockComment))
+    // No whitespace in x(/*foo=*/1), except for JavaScript.
+    return Style.isJavaScript() || !Left.TokenText.endswith("=*/");
+
+  // Space between template and attribute.
+  // e.g. template <typename T> [[nodiscard]] ...
+  if (Left.is(TT_TemplateCloser) && Right.is(TT_AttributeSquare))
+    return true;
+  // Space before parentheses common for all languages
+  if (Right.is(tok::l_paren)) {
+    if (Left.is(TT_TemplateCloser) && Right.isNot(TT_FunctionTypeLParen))
+      return spaceRequiredBeforeParens(Right);
+    if (Left.isOneOf(TT_RequiresClause, TT_RequiresClauseInARequiresExpression))
+      return Style.SpaceBeforeParensOptions.AfterRequiresInClause ||
+             spaceRequiredBeforeParens(Right);
+    if (Left.is(TT_RequiresExpression))
+      return Style.SpaceBeforeParensOptions.AfterRequiresInExpression ||
+             spaceRequiredBeforeParens(Right);
+    if ((Left.is(tok::r_paren) && Left.is(TT_AttributeParen)) ||
+        (Left.is(tok::r_square) && Left.is(TT_AttributeSquare)))
+      return true;
+    if (Left.is(TT_ForEachMacro))
+      return Style.SpaceBeforeParensOptions.AfterForeachMacros ||
+             spaceRequiredBeforeParens(Right);
+    if (Left.is(TT_IfMacro))
+      return Style.SpaceBeforeParensOptions.AfterIfMacros ||
+             spaceRequiredBeforeParens(Right);
+    if (Line.Type == LT_ObjCDecl)
+      return true;
+    if (Left.is(tok::semi))
+      return true;
+    if (Left.isOneOf(tok::pp_elif, tok::kw_for, tok::kw_while, tok::kw_switch,
+                     tok::kw_case, TT_ForEachMacro, TT_ObjCForIn))
+      return Style.SpaceBeforeParensOptions.AfterControlStatements ||
+             spaceRequiredBeforeParens(Right);
+    if (Left.isIf(Line.Type != LT_PreprocessorDirective))
+      return Style.SpaceBeforeParensOptions.AfterControlStatements ||
+             spaceRequiredBeforeParens(Right);
+
+    // TODO add Operator overloading specific Options to
+    // SpaceBeforeParensOptions
+    if (Right.is(TT_OverloadedOperatorLParen))
+      return spaceRequiredBeforeParens(Right);
+    // Function declaration or definition
+    if (Line.MightBeFunctionDecl && (Left.is(TT_FunctionDeclarationName))) {
+      if (Line.mightBeFunctionDefinition())
+        return Style.SpaceBeforeParensOptions.AfterFunctionDefinitionName ||
+               spaceRequiredBeforeParens(Right);
+      else
+        return Style.SpaceBeforeParensOptions.AfterFunctionDeclarationName ||
+               spaceRequiredBeforeParens(Right);
+    }
+    // Lambda
+    if (Line.Type != LT_PreprocessorDirective && Left.is(tok::r_square) &&
+        Left.MatchingParen && Left.MatchingParen->is(TT_LambdaLSquare))
+      return Style.SpaceBeforeParensOptions.AfterFunctionDefinitionName ||
+             spaceRequiredBeforeParens(Right);
+    if (!Left.Previous || Left.Previous->isNot(tok::period)) {
+      if (Left.isOneOf(tok::kw_try, Keywords.kw___except, tok::kw_catch))
+        return Style.SpaceBeforeParensOptions.AfterControlStatements ||
+               spaceRequiredBeforeParens(Right);
+      if (Left.isOneOf(tok::kw_new, tok::kw_delete))
+        return ((!Line.MightBeFunctionDecl || !Left.Previous) &&
+                Style.SpaceBeforeParens != FormatStyle::SBPO_Never) ||
+               spaceRequiredBeforeParens(Right);
+
+      if (Left.is(tok::r_square) && Left.MatchingParen &&
+          Left.MatchingParen->Previous &&
+          Left.MatchingParen->Previous->is(tok::kw_delete))
+        return (Style.SpaceBeforeParens != FormatStyle::SBPO_Never) ||
+               spaceRequiredBeforeParens(Right);
+    }
+    if (Line.Type != LT_PreprocessorDirective &&
+        (Left.is(tok::identifier) || Left.isFunctionLikeKeyword() ||
+         Left.is(tok::r_paren) || Left.isSimpleTypeSpecifier()))
+      return spaceRequiredBeforeParens(Right);
+    return false;
+  }
+  if (Left.is(tok::at) && Right.Tok.getObjCKeywordID() != tok::objc_not_keyword)
+    return false;
+  if (Right.is(TT_UnaryOperator))
+    return !Left.isOneOf(tok::l_paren, tok::l_square, tok::at) &&
+           (Left.isNot(tok::colon) || Left.isNot(TT_ObjCMethodExpr));
+  if ((Left.isOneOf(tok::identifier, tok::greater, tok::r_square,
+                    tok::r_paren) ||
+       Left.isSimpleTypeSpecifier()) &&
+      Right.is(tok::l_brace) && Right.getNextNonComment() &&
+      Right.isNot(BK_Block))
+    return false;
+  if (Left.is(tok::period) || Right.is(tok::period))
+    return false;
+  // u#str, U#str, L#str, u8#str
+  // uR#str, UR#str, LR#str, u8R#str
+  if (Right.is(tok::hash) && Left.is(tok::identifier) &&
+      (Left.TokenText == "L" || Left.TokenText == "u" ||
+       Left.TokenText == "U" || Left.TokenText == "u8" ||
+       Left.TokenText == "LR" || Left.TokenText == "uR" ||
+       Left.TokenText == "UR" || Left.TokenText == "u8R"))
+    return false;
+  if (Left.is(TT_TemplateCloser) && Left.MatchingParen &&
+      Left.MatchingParen->Previous &&
+      (Left.MatchingParen->Previous->is(tok::period) ||
+       Left.MatchingParen->Previous->is(tok::coloncolon)))
+    // Java call to generic function with explicit type:
+    // A.<B<C<...>>>DoSomething();
+    // A::<B<C<...>>>DoSomething();  // With a Java 8 method reference.
+    return false;
+  if (Left.is(TT_TemplateCloser) && Right.is(tok::l_square))
+    return false;
+  if (Left.is(tok::l_brace) && Left.endsSequence(TT_DictLiteral, tok::at))
+    // Objective-C dictionary literal -> no space after opening brace.
+    return false;
+  if (Right.is(tok::r_brace) && Right.MatchingParen &&
+      Right.MatchingParen->endsSequence(TT_DictLiteral, tok::at))
+    // Objective-C dictionary literal -> no space before closing brace.
+    return false;
+  if (Right.getType() == TT_TrailingAnnotation &&
+      Right.isOneOf(tok::amp, tok::ampamp) &&
+      Left.isOneOf(tok::kw_const, tok::kw_volatile) &&
+      (!Right.Next || Right.Next->is(tok::semi)))
+    // Match const and volatile ref-qualifiers without any additional
+    // qualifiers such as
+    // void Fn() const &;
+    return getTokenReferenceAlignment(Right) != FormatStyle::PAS_Left;
+
+  return true;
 }
 
 // Returns 'true' if 'Tok' is a brace we'd want to break before in Allman style.
 static bool isAllmanBrace(const FormatToken &Tok) {
   return Tok.is(tok::l_brace) && Tok.is(BK_Block) &&
          !Tok.isOneOf(TT_ObjCBlockLBrace, TT_LambdaLBrace, TT_DictLiteral);
 }