[clang-format] Distinguish logical and after bracket from reference

[jackhong12]

Summary

In https://reviews.llvm.org/D127873, I missed the case bool b = 3 == int{3} && true;.

The function modifyContext will annotate && as a reference operator if there is a = behind &&. So, we can remove these redundant rules.

[owenpan]

clang/lib/Format/TokenAnnotator.cpp

2367–2368

Removing it would suffice.

clang/unittests/Format/FormatTest.cpp

10477

Can you add a similar test in TokenAnnotatorTest.cpp?

[owenpan]

clang/unittests/Format/FormatTest.cpp

10477

Nvm.

[jackhong12]

This comment was removed by jackhong12.

[jackhong12]

Remove redundant code.

[owenpan]

LGTM

[jackhong12]

Is there any chance we also add this patch to version 15?

https://github.com/llvm/llvm-project/issues/57534#issuecomment-1236132578

[HazardyKnusperkeks]

You have to ask @tstellar to cherry-pick it.

clang/lib/Format/TokenAnnotator.cpp

TokenType determineStarAmpUsage(const FormatToken &Tok, bool IsExpression,
     // int i = int{42} * 2;
     // In the struct case, the part of the struct declaration until the `{` and
     // the `}` are put on separate unwrapped lines; in the brace-initialized
     // case, the matching `{` is on the same unwrapped line, so check for the
     // presence of the matching brace to distinguish between those.
     if (PrevToken->is(tok::r_brace) && Tok.is(tok::star) &&
         !PrevToken->MatchingParen)
       return TT_PointerOrReference;
 
-    // For "} &&"
-    if (PrevToken->is(tok::r_brace) && Tok.is(tok::ampamp)) {
-      const FormatToken *MatchingLBrace = PrevToken->MatchingParen;
-
-      // We check whether there is a TemplateCloser(">") to indicate it's a
-      // template or not. If it's not a template, "&&" is likely a reference
-      // operator.
-      //   struct {} &&ref = {};
-      if (!MatchingLBrace)
-        return TT_PointerOrReference;
-      FormatToken *BeforeLBrace = MatchingLBrace->getPreviousNonComment();
-      if (!BeforeLBrace || BeforeLBrace->isNot(TT_TemplateCloser))
-        return TT_PointerOrReference;
-
-      // If it is a template, "&&" is a binary operator.
-      //   enable_if<>{} && ...
-      return TT_BinaryOperator;
-    }
-
     if (PrevToken->Tok.isLiteral() ||
         PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::kw_true,
                            tok::kw_false, tok::r_brace)) {
       return TT_BinaryOperator;
     }
 
     const FormatToken *NextNonParen = NextToken;
     while (NextNonParen && NextNonParen->is(tok::l_paren))
       NextNonParen = NextNonParen->getNextNonComment();

clang/unittests/Format/FormatTest.cpp

verifyFormat("struct {\n"
                "}&& ptr = {};",
                Style);
   verifyFormat("union {\n"
                "}&& ptr = {};",
                Style);
   verifyFormat("class {\n"
                "}&& ptr = {};",
                Style);
+  verifyFormat("bool b = 3 == int{3} && true;");
 
   Style.PointerAlignment = FormatStyle::PAS_Middle;
   verifyFormat("struct {\n"
                "} * ptr;",
                Style);
   verifyFormat("union {\n"
                "} * ptr;",
                Style);

clang/unittests/Format/TokenAnnotatorTest.cpp

TEST_F(TokenAnnotatorTest, UnderstandsUsesOfStarAndAmp) {
 
   Tokens = annotate("case *x:");
   EXPECT_EQ(Tokens.size(), 5u) << Tokens;
   EXPECT_TOKEN(Tokens[1], tok::star, TT_UnaryOperator);
   Tokens = annotate("case &x:");
   EXPECT_EQ(Tokens.size(), 5u) << Tokens;
   EXPECT_TOKEN(Tokens[1], tok::amp, TT_UnaryOperator);
 
+  Tokens = annotate("bool b = 3 == int{3} && true;\n");
+  EXPECT_EQ(Tokens.size(), 13u) << Tokens;
+  EXPECT_TOKEN(Tokens[9], tok::ampamp, TT_BinaryOperator);
+
   Tokens = annotate("struct {\n"
                     "} *ptr;");
   EXPECT_EQ(Tokens.size(), 7u) << Tokens;
   EXPECT_TOKEN(Tokens[3], tok::star, TT_PointerOrReference);
   Tokens = annotate("union {\n"
                     "} *ptr;");
   EXPECT_EQ(Tokens.size(), 7u) << Tokens;
   EXPECT_TOKEN(Tokens[3], tok::star, TT_PointerOrReference);