[clang-format] Fix annotating when deleting array of pointers

[jackhong12]

Summary

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

The token * below should be annotated as UnaryOperator.

delete[] *ptr;

[jackhong12]

Annotate * as UnaryOperator instead of PointerOrReference

[MyDeveloperDay]

clang/lib/Format/TokenAnnotator.cpp

2379

Why unary here, doesn’t that make it a multiply?

[jackhong12]

In this case, I think it's dereferencing a pointer instead of multiplying two numbers.

[jackhong12]

clang/lib/Format/TokenAnnotator.cpp

2378–2382

The * token in delete *x; will be annotated as UnaryOperator (dereferencing a pointer).

In the case delete[] *x;, there is a ] before *. So, it will be annotated as BinaryOperator by this rule.

I think both * here should be UnaryOperator. Therefore, I add a new rule to match the delete[] pattern.

[MyDeveloperDay]

clang/lib/Format/TokenAnnotator.cpp

2378–2382

it will be annotated as BinaryOperator by this rule. of course my bad

clang/unittests/Format/FormatTest.cpp

10541

could you cover the other PointerAlignment case for completeness

[HazardyKnusperkeks]

Please mark comments as done, when the discussion has ended.

clang/lib/Format/TokenAnnotator.cpp

2376

I don't know if this is nice. I think I would prefer PrevToken->getPreviousNonComment() and subsequently PrevToken->getPreviousNonComment()->getPreviousNonComment().

[owenpan]

clang/lib/Format/TokenAnnotator.cpp

2375–2378

endsSequence() is exactly what you want here. ;)

clang/unittests/Format/FormatTest.cpp

10538

A typo?

10541

IMO, testing only PAS_Left would suffice as we just want to ensure that no spaces are added after the *s.

[jackhong12]

Use endsSequence to match the pattern

[jackhong12]

Add left alignment test

[jackhong12]

clang/lib/Format/TokenAnnotator.cpp

2375–2378

Thanks! It looks more concise now.

[owenpan]

Please mark https://reviews.llvm.org/D132911#inline-1279832 as done.

clang/lib/Format/TokenAnnotator.cpp

TokenType determineStarAmpUsage(const FormatToken &Tok, bool IsExpression,
     // 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;
 
+    if (PrevToken->endsSequence(tok::r_square, tok::l_square, tok::kw_delete))
+      return TT_UnaryOperator;
+
     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();
     if (NextNonParen && (NextNonParen->Tok.isLiteral() ||
                          NextNonParen->isOneOf(tok::kw_true, tok::kw_false) ||
                          NextNonParen->isUnaryOperator())) {
       return TT_BinaryOperator;

clang/unittests/Format/FormatTest.cpp

verifyFormat("struct {\n"
                Style);
   verifyFormat("union {\n"
                "} &&ptr = {};",
                Style);
   verifyFormat("class {\n"
                "} &&ptr = {};",
                Style);
 
+  Style.PointerAlignment = FormatStyle::PAS_Left;
+  verifyFormat("delete[] *ptr;", Style);
+  verifyFormat("delete[] **ptr;", Style);
+  verifyFormat("delete[] *(ptr);", Style);
+
   verifyIndependentOfContext("MACRO(int *i);");
   verifyIndependentOfContext("MACRO(auto *a);");
   verifyIndependentOfContext("MACRO(const A *a);");
   verifyIndependentOfContext("MACRO(_Atomic(A) *a);");
   verifyIndependentOfContext("MACRO(decltype(A) *a);");
   verifyIndependentOfContext("MACRO(typeof(A) *a);");
   verifyIndependentOfContext("MACRO(__underlying_type(A) *a);");
   verifyIndependentOfContext("MACRO(A *const a);");

clang/unittests/Format/TokenAnnotatorTest.cpp

TEST_F(TokenAnnotatorTest, UnderstandsUsesOfStarAndAmp) {
   EXPECT_TOKEN(Tokens[3], tok::ampamp, TT_PointerOrReference);
   Tokens = annotate("class {\n"
                     "} &&ptr = {};");
   EXPECT_EQ(Tokens.size(), 10u) << Tokens;
   EXPECT_TOKEN(Tokens[3], tok::ampamp, TT_PointerOrReference);
   Tokens = annotate("int i = int{42} * 2;");
   EXPECT_EQ(Tokens.size(), 11u) << Tokens;
   EXPECT_TOKEN(Tokens[7], tok::star, TT_BinaryOperator);
+
+  Tokens = annotate("delete[] *ptr;");
+  EXPECT_EQ(Tokens.size(), 7u) << Tokens;
+  EXPECT_TOKEN(Tokens[3], tok::star, TT_UnaryOperator);
+  Tokens = annotate("delete[] **ptr;");
+  EXPECT_EQ(Tokens.size(), 8u) << Tokens;
+  EXPECT_TOKEN(Tokens[3], tok::star, TT_UnaryOperator);
+  EXPECT_TOKEN(Tokens[4], tok::star, TT_UnaryOperator);
+  Tokens = annotate("delete[] *(ptr);");
+  EXPECT_EQ(Tokens.size(), 9u) << Tokens;
+  EXPECT_TOKEN(Tokens[3], tok::star, TT_UnaryOperator);
 }
 
 TEST_F(TokenAnnotatorTest, UnderstandsUsesOfPlusAndMinus) {
   auto Tokens = annotate("x - 0");
   ASSERT_EQ(Tokens.size(), 4u) << Tokens;
   EXPECT_TOKEN(Tokens[1], tok::minus, TT_BinaryOperator);
   Tokens = annotate("0 + 0");
   ASSERT_EQ(Tokens.size(), 4u) << Tokens;