[clang-format] Annotate constructor/destructor names

[owenpan]

Summary

Annotate constructor/destructor names as FunctionDeclarationName.

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

[HazardyKnusperkeks]

clang/lib/Format/TokenAnnotator.cpp

3104

Is a bit clearer.

[owenpan]

clang/lib/Format/TokenAnnotator.cpp

3104

I moved this function up to here from below and only removed a couple of consts. I can clean it up in another patch.

[owenpan]

clang/lib/Format/TokenAnnotator.cpp

3104

See D158104.

[owenpan]

Rebased to D158104 and simplified getFunctionName and isCtorOrDtorName a little.

[HazardyKnusperkeks]

@kadircet shouldn't you at least say why it got reverted? Even better state your problem and give a chance to fix before you revert?

[kadircet]

In D157963#4621206, @HazardyKnusperkeks wrote:

@kadircet shouldn't you at least say why it got reverted? Even better state your problem and give a chance to fix before you revert?

Hi, https://reviews.llvm.org/rG7590b7657004b33b1a12b05f8e9174db3e192f8c already has that context.

[owenpan]

clang/lib/Format/TokenAnnotator.cpp

3135

When simplifying the function, I forgot that we are in the inner loop here and thus break won't exit the outer loop.

[owenpan]

Fixed the crash and added a test case in TokenAnnotatorTest.cpp.

clang/lib/Format/TokenAnnotator.cpp

 
 static unsigned maxNestingDepth(const AnnotatedLine &Line) {
   unsigned Result = 0;
   for (const auto *Tok = Line.First; Tok; Tok = Tok->Next)
     Result = std::max(Result, Tok->NestingLevel);
   return Result;
 }
 
+// Returns the name of a function with no return type, e.g. a constructor or
+// destructor.
+static FormatToken *getFunctionName(const AnnotatedLine &Line) {
+  for (FormatToken *Tok = Line.getFirstNonComment(), *Name = nullptr; Tok;
+       Tok = Tok->getNextNonComment()) {
+    // Skip C++11 attributes both before and after the function name.
+    if (Tok->is(tok::l_square) && Tok->is(TT_AttributeSquare)) {
+      Tok = Tok->MatchingParen;
+      if (!Tok)
+        break;
+      continue;
+    }
+
+    // Make sure the name is followed by a pair of parentheses.
+    if (Name)
+      return Tok->is(tok::l_paren) && Tok->MatchingParen ? Name : nullptr;
+
+    // Skip keywords that may precede the constructor/destructor name.
+    if (Tok->isOneOf(tok::kw_friend, tok::kw_inline, tok::kw_virtual,
+                     tok::kw_constexpr, tok::kw_consteval, tok::kw_explicit)) {
+      continue;
+    }
+
+    // A qualified name may start from the global namespace.
+    if (Tok->is(tok::coloncolon)) {
+      Tok = Tok->Next;
+      if (!Tok)
+        break;
+    }
+
+    // Skip to the unqualified part of the name.
+    while (Tok->startsSequence(tok::identifier, tok::coloncolon)) {
+      assert(Tok->Next);
+      Tok = Tok->Next->Next;
+      if (!Tok)
+        return nullptr;
+    }
+
+    // Skip the `~` if a destructor name.
+    if (Tok->is(tok::tilde)) {
+      Tok = Tok->Next;
+      if (!Tok)
+        break;
+    }
+
+    // Make sure the name is not already annotated, e.g. as NamespaceMacro.
+    if (Tok->isNot(tok::identifier) || Tok->isNot(TT_Unknown))
+      break;
+
+    Name = Tok;
+  }
+
+  return nullptr;
+}
+
+// Checks if Tok is a constructor/destructor name qualified by its class name.
+static bool isCtorOrDtorName(const FormatToken *Tok) {
+  assert(Tok && Tok->is(tok::identifier));
+  const auto *Prev = Tok->Previous;
+
+  if (Prev && Prev->is(tok::tilde))
+    Prev = Prev->Previous;
+
+  if (!Prev || !Prev->endsSequence(tok::coloncolon, tok::identifier))
+    return false;
+
+  assert(Prev->Previous);
+  return Prev->Previous->TokenText == Tok->TokenText;
+}
+
 void TokenAnnotator::annotate(AnnotatedLine &Line) {
   for (auto &Child : Line.Children)
     annotate(*Child);
 
   AnnotatingParser Parser(Style, Line, Keywords, Scopes);
   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)
     Line.Type = LT_Invalid;
 
   if (Line.Type == LT_Invalid)
     return;
 
   ExpressionParser ExprParser(Style, Keywords, Line);
   ExprParser.parse();
 
+  if (Style.isCpp()) {
+    auto *Tok = getFunctionName(Line);
+    if (Tok && ((!Scopes.empty() && Scopes.back() == ST_Class) ||
+                Line.endsWith(TT_FunctionLBrace) || isCtorOrDtorName(Tok))) {
+      Tok->setFinalizedType(TT_FunctionDeclarationName);
+    }
+  }
+
   if (Line.startsWith(TT_ObjCMethodSpecifier))
     Line.Type = LT_ObjCMethodDecl;
   else if (Line.startsWith(TT_ObjCDecl))
     Line.Type = LT_ObjCDecl;
   else if (Line.startsWith(TT_ObjCProperty))
     Line.Type = LT_ObjCProperty;
 
   Line.First->SpacesRequiredBefore = 1;
   Line.First->CanBreakBefore = Line.First->MustBreakBefore;
 }
 
 // This function heuristically determines whether 'Current' starts the name of a
 // function declaration.
 static bool isFunctionDeclarationName(bool IsCpp, const FormatToken &Current,
                                       const AnnotatedLine &Line) {
   assert(Current.Previous);
+
+  if (Current.is(TT_FunctionDeclarationName))
+    return true;
+
   if (!Current.Tok.getIdentifierInfo())
     return false;
 
   auto skipOperatorName = [](const FormatToken *Next) -> const FormatToken * {
     for (; Next; Next = Next->Next) {
       if (Next->is(TT_OverloadedOperatorLParen))
         return Next;
       if (Next->is(TT_OverloadedOperator))
bool AlignArrayOfStructures =
       (Style.AlignArrayOfStructures != FormatStyle::AIAS_None &&
        Line.Type == LT_ArrayOfStructInitializer);
   if (AlignArrayOfStructures)
     calculateArrayInitializerColumnList(Line);
 
   bool LineIsFunctionDeclaration = false;
   for (FormatToken *Tok = Current, *AfterLastAttribute = nullptr; Tok;
        Tok = Tok->Next) {
+    if (Tok->Previous->EndsCppAttributeGroup)
+      AfterLastAttribute = Tok;
     if (isFunctionDeclarationName(Style.isCpp(), *Tok, Line)) {
       LineIsFunctionDeclaration = true;
-      Tok->setType(TT_FunctionDeclarationName);
+      Tok->setFinalizedType(TT_FunctionDeclarationName);
       if (AfterLastAttribute &&
           mustBreakAfterAttributes(*AfterLastAttribute, Style)) {
         AfterLastAttribute->MustBreakBefore = true;
         Line.ReturnTypeWrapped = true;
       }
       break;
     }
-    if (Tok->Previous->EndsCppAttributeGroup)
-      AfterLastAttribute = Tok;
   }
 
   if (Style.isCpp() && !LineIsFunctionDeclaration) {
     // Annotate */&/&& in `operator` function calls as binary operators.
     for (const auto *Tok = Line.First; Tok; Tok = Tok->Next) {
       if (Tok->isNot(tok::kw_operator))
         continue;
       do {

clang/unittests/Format/FormatTest.cpp

verifyFormat("M(std::size_t R, std::size_t C) : C(C), data(R) {}",
                SpaceFuncDecl);
 
   FormatStyle SpaceFuncDef = getLLVMStyle();
   SpaceFuncDef.SpaceBeforeParens = FormatStyle::SBPO_Custom;
   SpaceFuncDef.SpaceBeforeParensOptions.AfterFunctionDefinitionName = true;
 
   verifyFormat("int f();", SpaceFuncDef);
   verifyFormat("void f (int a, T b) {}", SpaceFuncDef);
-  verifyFormat("A::A() : a(1) {}", SpaceFuncDef);
+  verifyFormat("A::A () : a(1) {}", SpaceFuncDef);
   verifyFormat("void f() __attribute__((asdf));", SpaceFuncDef);
   verifyFormat("#define A(x) x", SpaceFuncDef);
   verifyFormat("#define A (x) x", SpaceFuncDef);
   verifyFormat("#if defined(x)\n"
                "#endif",
                SpaceFuncDef);
   verifyFormat("auto i = std::make_unique<int>(5);", SpaceFuncDef);
   verifyFormat("size_t x = sizeof(x);", SpaceFuncDef);
   verifyFormat("auto f(int x) -> decltype(x);", SpaceFuncDef);
   verifyFormat("auto f(int x) -> typeof(x);", SpaceFuncDef);
   verifyFormat("auto f(int x) -> _Atomic(x);", SpaceFuncDef);
   verifyFormat("auto f(int x) -> __underlying_type(x);", SpaceFuncDef);
   verifyFormat("int f(T x) noexcept(x.create());", SpaceFuncDef);
   verifyFormat("alignas(128) char a[128];", SpaceFuncDef);
   verifyFormat("size_t x = alignof(MyType);", SpaceFuncDef);
   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");",
                SpaceFuncDef);
   verifyFormat("int f() throw(Deprecated);", SpaceFuncDef);
   verifyFormat("typedef void (*cb)(int);", SpaceFuncDef);
   verifyFormat("T A::operator()();", SpaceFuncDef);
   verifyFormat("X A::operator++(T);", SpaceFuncDef);
   // verifyFormat("T A::operator() () {}", SpaceFuncDef);
   verifyFormat("auto lambda = [] () { return 0; };", SpaceFuncDef);
   verifyFormat("int x = int(y);", SpaceFuncDef);
-  verifyFormat("M(std::size_t R, std::size_t C) : C(C), data(R) {}",
+  verifyFormat("M (std::size_t R, std::size_t C) : C(C), data(R) {}",
                SpaceFuncDef);
 
   FormatStyle SpaceIfMacros = getLLVMStyle();
   SpaceIfMacros.IfMacros.clear();
   SpaceIfMacros.IfMacros.push_back("MYIF");
   SpaceIfMacros.SpaceBeforeParens = FormatStyle::SBPO_Custom;
   SpaceIfMacros.SpaceBeforeParensOptions.AfterIfMacros = true;
   verifyFormat("MYIF (a)\n  return;", SpaceIfMacros);
verifyFormat("void foo() {} //\n"
                Style);
 #endif
 }
 
 TEST_F(FormatTest, BreakAfterAttributes) {
   FormatStyle Style = getLLVMStyle();
   EXPECT_EQ(Style.BreakAfterAttributes, FormatStyle::ABS_Never);
 
-  const StringRef Code("[[nodiscard]] inline int f(int &i);\n"
+  constexpr StringRef Code("[[nodiscard]] inline int f(int &i);\n"
                            "[[foo([[]])]] [[nodiscard]]\n"
                            "int g(int &i);\n"
                            "[[nodiscard]]\n"
                            "inline int f(int &i) {\n"
                            "  i = 1;\n"
                            "  return 0;\n"
                            "}\n"
                            "[[foo([[]])]] [[nodiscard]] int g(int &i) {\n"
                            "  i = 0;\n"
                            "  return 1;\n"
                            "}");
 
   verifyFormat("[[nodiscard]] inline int f(int &i);\n"
                "[[foo([[]])]] [[nodiscard]] int g(int &i);\n"
                "[[nodiscard]] inline int f(int &i) {\n"
                "  i = 1;\n"
                "  return 0;\n"
                "}\n"
                "[[foo([[]])]] [[nodiscard]] int g(int &i) {\n"
                "  i = 0;\n"
                "  return 1;\n"
                "}",
                Code, Style);
 
+  Style.BreakAfterAttributes = FormatStyle::ABS_Leave;
+  verifyNoChange(Code, Style);
+
   Style.BreakAfterAttributes = FormatStyle::ABS_Always;
   verifyFormat("[[nodiscard]]\n"
                "inline int f(int &i);\n"
                "[[foo([[]])]] [[nodiscard]]\n"
                "int g(int &i);\n"
                "[[nodiscard]]\n"
                "inline int f(int &i) {\n"
                "  i = 1;\n"
                "  return 0;\n"
                "}\n"
                "[[foo([[]])]] [[nodiscard]]\n"
                "int g(int &i) {\n"
                "  i = 0;\n"
                "  return 1;\n"
                "}",
                Code, Style);
 
-  Style.BreakAfterAttributes = FormatStyle::ABS_Leave;
-  verifyNoChange(Code, Style);
+  constexpr StringRef CtorDtorCode("struct Foo {\n"
+                                   "  [[deprecated]] Foo();\n"
+                                   "  [[deprecated]] Foo() {}\n"
+                                   "  [[deprecated]] ~Foo();\n"
+                                   "  [[deprecated]] ~Foo() {}\n"
+                                   "  [[deprecated]] void f();\n"
+                                   "  [[deprecated]] void f() {}\n"
+                                   "};\n"
+                                   "[[deprecated]] Bar::Bar() {}\n"
+                                   "[[deprecated]] Bar::~Bar() {}\n"
+                                   "[[deprecated]] void g() {}");
+  verifyFormat("struct Foo {\n"
+               "  [[deprecated]]\n"
+               "  Foo();\n"
+               "  [[deprecated]]\n"
+               "  Foo() {}\n"
+               "  [[deprecated]]\n"
+               "  ~Foo();\n"
+               "  [[deprecated]]\n"
+               "  ~Foo() {}\n"
+               "  [[deprecated]]\n"
+               "  void f();\n"
+               "  [[deprecated]]\n"
+               "  void f() {}\n"
+               "};\n"
+               "[[deprecated]]\n"
+               "Bar::Bar() {}\n"
+               "[[deprecated]]\n"
+               "Bar::~Bar() {}\n"
+               "[[deprecated]]\n"
+               "void g() {}",
+               CtorDtorCode, Style);
+
+  Style.BreakBeforeBraces = FormatStyle::BS_Linux;
+  verifyFormat("struct Foo {\n"
+               "  [[deprecated]]\n"
+               "  Foo();\n"
+               "  [[deprecated]]\n"
+               "  Foo()\n"
+               "  {\n"
+               "  }\n"
+               "  [[deprecated]]\n"
+               "  ~Foo();\n"
+               "  [[deprecated]]\n"
+               "  ~Foo()\n"
+               "  {\n"
+               "  }\n"
+               "  [[deprecated]]\n"
+               "  void f();\n"
+               "  [[deprecated]]\n"
+               "  void f()\n"
+               "  {\n"
+               "  }\n"
+               "};\n"
+               "[[deprecated]]\n"
+               "Bar::Bar()\n"
+               "{\n"
+               "}\n"
+               "[[deprecated]]\n"
+               "Bar::~Bar()\n"
+               "{\n"
+               "}\n"
+               "[[deprecated]]\n"
+               "void g()\n"
+               "{\n"
+               "}",
+               CtorDtorCode, Style);
 }
 
 TEST_F(FormatTest, InsertNewlineAtEOF) {
   FormatStyle Style = getLLVMStyle();
   Style.InsertNewlineAtEOF = true;
 
   verifyNoChange("int i;\n", Style);
   verifyFormat("int i;\n", "int i;", Style);

clang/unittests/Format/TokenAnnotatorTest.cpp

 TEST_F(TokenAnnotatorTest, UnderstandsFunctionDeclarationNames) {
   auto Tokens = annotate("void f [[noreturn]] ();");
   ASSERT_EQ(Tokens.size(), 11u) << Tokens;
   EXPECT_TOKEN(Tokens[1], tok::identifier, TT_FunctionDeclarationName);
 
   Tokens = annotate("void f [[noreturn]] () {}");
   ASSERT_EQ(Tokens.size(), 12u) << Tokens;
   EXPECT_TOKEN(Tokens[1], tok::identifier, TT_FunctionDeclarationName);
+
+  Tokens = annotate("class Foo { public: Foo(); };");
+  ASSERT_EQ(Tokens.size(), 12u) << Tokens;
+  EXPECT_TOKEN(Tokens[5], tok::identifier, TT_FunctionDeclarationName);
+
+  Tokens = annotate("class Foo { public: ~Foo(); };");
+  ASSERT_EQ(Tokens.size(), 13u) << Tokens;
+  EXPECT_TOKEN(Tokens[6], tok::identifier, TT_FunctionDeclarationName);
+
+  Tokens = annotate("struct Foo { [[deprecated]] Foo() {} };");
+  ASSERT_EQ(Tokens.size(), 16u) << Tokens;
+  EXPECT_TOKEN(Tokens[8], tok::identifier, TT_FunctionDeclarationName);
+  EXPECT_TOKEN(Tokens[11], tok::l_brace, TT_FunctionLBrace);
+
+  Tokens = annotate("struct Foo { [[deprecated]] ~Foo() {} };");
+  ASSERT_EQ(Tokens.size(), 17u) << Tokens;
+  EXPECT_TOKEN(Tokens[9], tok::identifier, TT_FunctionDeclarationName);
+  EXPECT_TOKEN(Tokens[12], tok::l_brace, TT_FunctionLBrace);
+
+  Tokens = annotate("struct Foo { Foo() [[deprecated]] {} };");
+  ASSERT_EQ(Tokens.size(), 16u) << Tokens;
+  EXPECT_TOKEN(Tokens[3], tok::identifier, TT_FunctionDeclarationName);
+  EXPECT_TOKEN(Tokens[11], tok::l_brace, TT_FunctionLBrace);
+
+  Tokens = annotate("struct Foo { ~Foo() [[deprecated]] {} };");
+  ASSERT_EQ(Tokens.size(), 17u) << Tokens;
+  EXPECT_TOKEN(Tokens[4], tok::identifier, TT_FunctionDeclarationName);
+  EXPECT_TOKEN(Tokens[12], tok::l_brace, TT_FunctionLBrace);
+
+  Tokens = annotate("struct Foo { [[deprecated]] explicit Foo() {} };");
+  ASSERT_EQ(Tokens.size(), 17u) << Tokens;
+  EXPECT_TOKEN(Tokens[9], tok::identifier, TT_FunctionDeclarationName);
+  EXPECT_TOKEN(Tokens[12], tok::l_brace, TT_FunctionLBrace);
+
+  Tokens = annotate("struct Foo { virtual [[deprecated]] ~Foo() {} };");
+  ASSERT_EQ(Tokens.size(), 18u) << Tokens;
+  EXPECT_TOKEN(Tokens[10], tok::identifier, TT_FunctionDeclarationName);
+  EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_FunctionLBrace);
+
+  Tokens = annotate("Foo::Foo() {}");
+  ASSERT_EQ(Tokens.size(), 8u) << Tokens;
+  EXPECT_TOKEN(Tokens[2], tok::identifier, TT_FunctionDeclarationName);
+  EXPECT_TOKEN(Tokens[5], tok::l_brace, TT_FunctionLBrace);
+
+  Tokens = annotate("Foo::~Foo() {}");
+  ASSERT_EQ(Tokens.size(), 9u) << Tokens;
+  EXPECT_TOKEN(Tokens[3], tok::identifier, TT_FunctionDeclarationName);
+  EXPECT_TOKEN(Tokens[6], tok::l_brace, TT_FunctionLBrace);
+
+  Tokens = annotate("#define FOO Foo::\n"
+                    "FOO Foo();");
+  ASSERT_EQ(Tokens.size(), 11u) << Tokens;
+  EXPECT_TOKEN(Tokens[6], tok::identifier, TT_FunctionDeclarationName);
 }
 
 TEST_F(TokenAnnotatorTest, UnderstandsC11GenericSelection) {
   auto Tokens = annotate("_Generic(x, int: 1, default: 0)");
   ASSERT_EQ(Tokens.size(), 13u) << Tokens;
   EXPECT_TOKEN(Tokens[0], tok::kw__Generic, TT_Unknown);
   EXPECT_TOKEN(Tokens[5], tok::colon, TT_GenericSelectionColon);
   EXPECT_TOKEN(Tokens[9], tok::colon, TT_GenericSelectionColon);