[clang] [clang-format] Improve BlockIndent at ColumnLimit (PR #93140)

[Owen Pan via cfe-commits]

================
@@ -803,6 +803,51 @@ void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
     return !Tok.Previous->isOneOf(TT_CastRParen, tok::kw_for, tok::kw_while,
                                   tok::kw_switch);
   };
+  auto IsLambdaParameterList = [](const FormatToken *Tok) {
+    // adapted from TokenAnnotator.cpp:isLambdaParameterList()
+    // Skip <...> if present.
+    if (Tok->Previous && Tok->Previous->is(tok::greater) &&
+        Tok->Previous->MatchingParen &&
+        Tok->Previous->MatchingParen->is(TT_TemplateOpener)) {
+      Tok = Tok->Previous->MatchingParen;
+    }
+
+    // Check for `[...]`.
+    return Tok->Previous && Tok->Previous->is(tok::r_square) &&
+           Tok->Previous->MatchingParen &&
+           Tok->Previous->MatchingParen->is(TT_LambdaLSquare);
+  };
+  auto IsFunctionCallParen = [&](const FormatToken &Tok) {
+    return Tok.is(tok::l_paren) && Tok.ParameterCount > 0 && Tok.Previous &&
+           Tok.Previous->is(tok::identifier);
+  };
+  const auto IsInTemplateString = [&](const FormatToken &Tok) {
+    if (!Style.isJavaScript())
+      return false;
+    for (const FormatToken *Prev = &Tok; Prev; Prev = Prev->Previous) {
+      if (Prev->is(TT_TemplateString) && Prev->opensScope())
+        return true;
+      if (Prev->is(TT_TemplateString) && Prev->closesScope())
+        break;
+    }
+    return false;
+  };
+  // Identifies simple (no expression) one-argument function calls.
+  const auto IsNotSimpleFunction = [&](const FormatToken &Tok) {
+    const auto *Previous = Tok.Previous;
+    const auto *Next = Tok.Next;
+    if (Tok.FakeLParens.size() > 0 && Tok.FakeLParens.back() > prec::Unknown)
+      return true;
+    if (Previous &&
+        (Previous->is(TT_FunctionDeclarationLParen) ||
+         IsFunctionCallParen(*Previous) || IsLambdaParameterList(Previous))) {
+      return !IsOpeningBracket(Tok) && Next && !Next->isMemberAccess() &&
+             !IsInTemplateString(Tok) &&
+             !Next->is(TT_FunctionDeclarationLParen) &&
+             !IsFunctionCallParen(*Next);
+    }
+    return false;
+  };
----------------
owenca wrote:

I'd drop the `Not` and rewrite it as something like below:
```
   // Identifies simple (no expression) one-argument function calls.
-  const auto IsNotSimpleFunction = [&](const FormatToken &Tok) {
+  const auto IsSimpleFunctionCall = [&](const FormatToken &Tok) {
+    if (!Tok.FakeLParens.empty() && Tok.FakeLParens.back() > prec::Unknown)
+      return false;
     const auto *Previous = Tok.Previous;
-    const auto *Next = Tok.Next;
-    if (Tok.FakeLParens.size() > 0 && Tok.FakeLParens.back() > prec::Unknown)
+    if (!Previous || (!Previous->isOneOf(TT_FunctionDeclarationLParen,
+                                         TT_LambdaDefinitionLParen) &&
+                      !IsFunctionCallParen(*Previous))) {
       return true;
-    if (Previous &&
-        (Previous->is(TT_FunctionDeclarationLParen) ||
-         IsFunctionCallParen(*Previous) || IsLambdaParameterList(Previous))) {
-      return !IsOpeningBracket(Tok) && Next && !Next->isMemberAccess() &&
-             !IsInTemplateString(Tok) &&
-             !Next->is(TT_FunctionDeclarationLParen) &&
-             !IsFunctionCallParen(*Next);
     }
-    return false;
+    if (IsOpeningBracket(Tok) || IsInTemplateString(Tok))
+      return true;
+    const auto *Next = Tok.Next;
+    return !Next || Next->isMemberAccess() ||
+           Next->is(TT_FunctionDeclarationLParen) || IsFunctionCallParen(*Next);
   };
```

https://github.com/llvm/llvm-project/pull/93140