[clangd] go-to-def on new/delete targets the constructor

[sammccall]

Summary

Related to https://github.com/clangd/clangd/issues/1321
(but does not actually change the behavior of find-refs)

clang-tools-extra/clangd/FindTarget.cpp

struct Visitor : public ConstStmtVisitor<Visitor> {
       }
       void VisitOverloadExpr(const OverloadExpr *OE) {
         for (auto *D : OE->decls())
           Outer.add(D, Flags);
       }
       void VisitSizeOfPackExpr(const SizeOfPackExpr *SE) {
         Outer.add(SE->getPack(), Flags);
       }
+      void VisitCXXNewExpr(const CXXNewExpr *CNE) {
+        Outer.add(CNE->getOperatorNew(), Flags);
+        // Also consider `new` a reference to any constructor that is called.
+        if (auto *CCE = CNE->getConstructExpr())
+          Outer.add(CCE, Flags);
+        // FIXME: heuristically resolve constructors in dependent code.
+      }
+      void VisitCXXDeleteExpr(const CXXDeleteExpr *CDE) {
+        Outer.add(CDE->getOperatorDelete(), Flags);
+        // Also consider `delete` a reference to any destructor that is called.
+        QualType T = CDE->getDestroyedType();
+        if (T.isNull())
+          return;
+        if (const auto *CRD = T->getAsCXXRecordDecl()) {
+          if (auto *CDD = CRD->getDestructor())
+            Outer.add(CDD, Flags);
+        }
+        // FIXME: heuristically resolve destructors in dependent code.
+      }
       void VisitCXXConstructExpr(const CXXConstructExpr *CCE) {
         Outer.add(CCE->getConstructor(), Flags);
       }
+      void
+      VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *CCE) {
+        // FIXME: heuristically resolve constructors in dependent code.
+      }
       void VisitDesignatedInitExpr(const DesignatedInitExpr *DIE) {
         for (const DesignatedInitExpr::Designator &D :
              llvm::reverse(DIE->designators()))
           if (D.isFieldDesignator()) {
             Outer.add(D.getField(), Flags);
             // We don't know which designator was intended, we assume the outer.
             break;
           }
struct Visitor : public ConstStmtVisitor<Visitor> {
         Outer.add(OPE->getProtocol(), Flags);
       }
       void VisitOpaqueValueExpr(const OpaqueValueExpr *OVE) {
         Outer.add(OVE->getSourceExpr(), Flags);
       }
       void VisitPseudoObjectExpr(const PseudoObjectExpr *POE) {
         Outer.add(POE->getSyntacticForm(), Flags);
       }
-      void VisitCXXNewExpr(const CXXNewExpr *CNE) {
-        Outer.add(CNE->getOperatorNew(), Flags);
-      }
-      void VisitCXXDeleteExpr(const CXXDeleteExpr *CDE) {
-        Outer.add(CDE->getOperatorDelete(), Flags);
-      }
     };
     Visitor(*this, Flags).Visit(S);
   }
 
   void add(QualType T, RelSet Flags) {
     if (T.isNull())
       return;
     debug(T, Flags);

clang-tools-extra/clangd/HeuristicResolver.h

 #include "clang/AST/Decl.h"
 #include <vector>
 
 namespace clang {
 
 class ASTContext;
 class CallExpr;
 class CXXDependentScopeMemberExpr;
+class CXXDestructorDecl;
 class DeclarationName;
 class DependentScopeDeclRefExpr;
 class NamedDecl;
 class Type;
 class UnresolvedUsingValueDecl;
 
 namespace clangd {
 

clang-tools-extra/clangd/unittests/FindTargetTests.cpp

Code = R"cpp(
     void foo(X x, T t) {
       x.[[func]](t);
     };
   )cpp";
   EXPECT_DECLS("UnresolvedMemberExpr", "void func(int *)", "void func(char *)");
 
   Code = R"cpp(
     struct X {
+      X();
       static void *operator new(unsigned long);
     };
     auto* k = [[new]] X();
   )cpp";
-  EXPECT_DECLS("CXXNewExpr", "static void *operator new(unsigned long)");
+  EXPECT_DECLS("CXXNewExpr", "static void *operator new(unsigned long)", "X()");
   Code = R"cpp(
     void *operator new(unsigned long);
     auto* k = [[new]] int();
   )cpp";
   EXPECT_DECLS("CXXNewExpr", "void *operator new(unsigned long)");
 
   Code = R"cpp(
     struct X {
+      ~X();
       static void operator delete(void *) noexcept;
     };
     void k(X* x) {
       [[delete]] x;
     }
   )cpp";
-  EXPECT_DECLS("CXXDeleteExpr", "static void operator delete(void *) noexcept");
+  EXPECT_DECLS("CXXDeleteExpr", "static void operator delete(void *) noexcept",
+               "~X() noexcept");
   Code = R"cpp(
     void operator delete(void *) noexcept;
     void k(int* x) {
       [[delete]] x;
     }
   )cpp";
   EXPECT_DECLS("CXXDeleteExpr", "void operator delete(void *) noexcept");
 }