[AST] Add DeclarationNameInfo to node introspection

[steveire]

Update

[steveire]

Update

[njames93]

clang/include/clang/Tooling/NodeIntrospection.h

29

Please fix this lint warning.

clang/lib/Tooling/DumpTool/generate_cxx_src_locs.py

393–394

Kind of unrelated, but can these not be replaced with cladeName not in RefClades?

clang/unittests/Introspection/IntrospectionTest.cpp

1425–1427

Can this be replace with a

if (!NodeIntrospection::hasIntrospectionSupport())
  return;

Check at the start of the test?

Same goes for the rest of the tests added here.

[steveire]

Update

clang/include/clang/Tooling/NodeIntrospection.h

 namespace clang {
 
 class Stmt;
 class Decl;
 class CXXCtorInitializer;
 class NestedNameSpecifierLoc;
 class TemplateArgumentLoc;
 class CXXBaseSpecifier;
+struct DeclarationNameInfo;
 
 namespace tooling {
 
 class LocationCall;
 using SharedLocationCall = llvm::IntrusiveRefCntPtr<LocationCall>;
 
 class LocationCall : public llvm::ThreadSafeRefCountedBase<LocationCall> {
 public:

 bool hasIntrospectionSupport();
 NodeLocationAccessors GetLocations(clang::Stmt const *Object);
 NodeLocationAccessors GetLocations(clang::Decl const *Object);
 NodeLocationAccessors GetLocations(clang::CXXCtorInitializer const *Object);
 NodeLocationAccessors GetLocations(clang::NestedNameSpecifierLoc const &);
 NodeLocationAccessors GetLocations(clang::TemplateArgumentLoc const &);
 NodeLocationAccessors GetLocations(clang::CXXBaseSpecifier const *);
 NodeLocationAccessors GetLocations(clang::TypeLoc const &);
+NodeLocationAccessors GetLocations(clang::DeclarationNameInfo const &);
 NodeLocationAccessors GetLocations(clang::DynTypedNode const &Node);
 } // namespace NodeIntrospection
 } // namespace tooling
 } // namespace clang
 #endif

clang/lib/Tooling/DumpTool/APIData.h

 
 struct ClassData {
   std::vector<std::string> ASTClassLocations;
   std::vector<std::string> ASTClassRanges;
   std::vector<std::string> TemplateParms;
   std::vector<std::string> TypeSourceInfos;
   std::vector<std::string> TypeLocs;
   std::vector<std::string> NestedNameLocs;
-  // TODO: Extend this with locations available via typelocs etc.
+  std::vector<std::string> DeclNameInfos;
 };
 
 } // namespace tooling
 } // namespace clang
 
 #endif

clang/lib/Tooling/DumpTool/ASTSrcLocProcessor.cpp

 
 ASTSrcLocProcessor::ASTSrcLocProcessor(StringRef JsonPath)
     : JsonPath(JsonPath) {
 
   MatchFinder::MatchFinderOptions FinderOptions;
 
   Finder = std::make_unique<MatchFinder>(std::move(FinderOptions));
   Finder->addMatcher(
-          cxxRecordDecl(
-              isDefinition(),
-              isSameOrDerivedFrom(
-                  // TODO: Extend this with other clades
-                  namedDecl(hasAnyName("clang::Stmt", "clang::Decl",
-                                       "clang::CXXCtorInitializer",
-                                       "clang::NestedNameSpecifierLoc",
-                                       "clang::TemplateArgumentLoc",
-                                       "clang::CXXBaseSpecifier",
-                                       "clang::TypeLoc"))
-                      .bind("nodeClade")),
-              optionally(isDerivedFrom(cxxRecordDecl().bind("derivedFrom"))))
-              .bind("className"),
+              namedDecl(
+                  hasAnyName(
+                      "clang::Stmt", "clang::Decl", "clang::CXXCtorInitializer",
+                      "clang::TemplateArgumentLoc", "clang::CXXBaseSpecifier",
+                      "clang::DeclarationNameInfo", "clang::TypeLoc"))
       this);
   Finder->addMatcher(
           cxxRecordDecl(isDefinition(), hasAnyName("clang::PointerLikeTypeLoc",
                                                    "clang::TypeofLikeTypeLoc"))
               .bind("templateName"),
       this);
 }
 
llvm::json::Object toJSON(ClassData const &Obj) {
   if (!Obj.TemplateParms.empty())
     JsonObj["templateParms"] = Obj.TemplateParms;
   if (!Obj.TypeSourceInfos.empty())
     JsonObj["typeSourceInfos"] = Obj.TypeSourceInfos;
   if (!Obj.TypeLocs.empty())
     JsonObj["typeLocs"] = Obj.TypeLocs;
   if (!Obj.NestedNameLocs.empty())
     JsonObj["nestedNameLocs"] = Obj.NestedNameLocs;
+  if (!Obj.DeclNameInfos.empty())
+    JsonObj["declNameInfos"] = Obj.DeclNameInfos;
   return JsonObj;
 }
 
 llvm::json::Object toJSON(llvm::StringMap<ClassData> const &Obj) {
   using llvm::json::toJSON;
 
   llvm::json::Object JsonObj;
   for (const auto &Item : Obj)
CD.ASTClassLocations =
       CaptureMethods("class clang::SourceLocation", ASTClass, Result);
   CD.ASTClassRanges =
       CaptureMethods("class clang::SourceRange", ASTClass, Result);
   CD.TypeSourceInfos =
       CaptureMethods("class clang::TypeSourceInfo *", ASTClass, Result);
   CD.TypeLocs = CaptureMethods("class clang::TypeLoc", ASTClass, Result);
   CD.NestedNameLocs =
       CaptureMethods("class clang::NestedNameSpecifierLoc", ASTClass, Result);
+  CD.DeclNameInfos =
+      CaptureMethods("struct clang::DeclarationNameInfo", ASTClass, Result);
 
   if (const auto *DerivedFrom =
           Result.Nodes.getNodeAs<clang::CXXRecordDecl>("derivedFrom")) {
 
     if (const auto *Templ =
             llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(
                 DerivedFrom)) {
 

clang/lib/Tooling/DumpTool/generate_cxx_src_locs.py

 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
 import os
 import sys
 import json
 import filecmp
 import shutil
 import argparse
 
 class Generator(object):
 
     implementationContent = ''
 
-    RefClades = {"NestedNameSpecifierLoc", "TemplateArgumentLoc", "TypeLoc"}
+    RefClades = {"DeclarationNameInfo",
+        "NestedNameSpecifierLoc",
+        "TemplateArgumentLoc",
+        "TypeLoc"}
 
     def __init__(self, templateClasses):
         self.templateClasses = templateClasses
 
     def GeneratePrologue(self):
 
         self.implementationContent += \
             """
""".format(locName)
                     """
   Rngs.insert(RangeAndString(Object.{0}(),
     llvm::makeIntrusiveRefCnt<LocationCall>(Prefix, "{0}")));
 """.format(rngName)
 
             self.implementationContent += '\n'
 
         if 'typeLocs' in ClassData or 'typeSourceInfos' in ClassData \
-                or 'nestedNameLocs' in ClassData:
+                or 'nestedNameLocs' in ClassData \
+                or 'declNameInfos' in ClassData:
             if CreateLocalRecursionGuard:
                 self.implementationContent += \
                     'std::vector<clang::TypeLoc> TypeLocRecursionGuard;\n'
 
             self.implementationContent += '\n'
 
             if 'typeLocs' in ClassData:
                 for typeLoc in ClassData['typeLocs']:
""".format(rngName)
                     self.implementationContent += \
                         """
               if (Object.{0}())
                 GetLocationsImpl(
                     llvm::makeIntrusiveRefCnt<LocationCall>(Prefix, "{0}"),
                     Object.{0}(), Locs, Rngs, TypeLocRecursionGuard);
               """.format(NN)
 
+            if 'declNameInfos' in ClassData:
+                for declName in ClassData['declNameInfos']:
+
+                    self.implementationContent += \
+                        """
+                      GetLocationsImpl(
+                          llvm::makeIntrusiveRefCnt<LocationCall>(Prefix, "{0}"),
+                          Object.{0}(), Locs, Rngs, TypeLocRecursionGuard);
+                      """.format(declName)
 
         self.implementationContent += '}\n'
 
     def GenerateFiles(self, OutputFile):
         with open(os.path.join(os.getcwd(),
                   OutputFile), 'w') as f:
             f.write(self.implementationContent)
 
def GenerateDynNodeVisitor(self, CladeNames):
 
         Signature = \
             'GetLocations(clang::DynTypedNode const &Node)'
 
         self.implementationContent += MethodReturnType \
             + ' NodeIntrospection::' + Signature + '{'
 
         for CladeName in CladeNames:
+            if CladeName == "DeclarationNameInfo":
+                continue
             self.implementationContent += \
                 """
     if (const auto *N = Node.get<{0}>())
     """.format(CladeName)
             ArgPrefix = ""
             if CladeName in self.RefClades:
                 ArgPrefix = "*"
             self.implementationContent += \
def main():
     def getCladeName(ClassName):
       for (CladeName, ClassNameData) in jsonData['classesInClade'].items():
         if ClassName in ClassNameData:
           return CladeName
 
     for (ClassName, ClassAccessors) in jsonData['classEntries'].items():
         cladeName = getCladeName(ClassName)
         g.GenerateSrcLocMethod(
             ClassName, ClassAccessors,
-            cladeName not in [
-                      'NestedNameSpecifierLoc',
-                      'TemplateArgumentLoc',
-                      'TypeLoc'])
+            cladeName not in Generator.RefClades)
 
     for (CladeName, ClassNameData) in jsonData['classesInClade'].items():
         g.GenerateBaseGetLocationsFunction(
             ClassNameData,
             jsonData['classEntries'],
             CladeName,
             jsonData["classInheritance"],
-            CladeName not in [
-                      'NestedNameSpecifierLoc',
-                      'TemplateArgumentLoc',
-                      'TypeLoc'])
+            CladeName not in Generator.RefClades)
 
     g.GenerateDynNodeVisitor(jsonData['classesInClade'].keys())
 
     g.GenerateEpilogue()
 
     g.GenerateFiles(options.output_file)
 
 if __name__ == '__main__':
     main()

clang/lib/Tooling/EmptyNodeIntrospection.inc.in

 NodeLocationAccessors NodeIntrospection::GetLocations(
     clang::CXXBaseSpecifier const*) {
   return {};
 }
 NodeLocationAccessors NodeIntrospection::GetLocations(
     clang::TypeLoc const&) {
   return {};
 }
+NodeLocationAccessors NodeIntrospection::GetLocations(
+    clang::DeclarationNameInfo const&) {
+  return {};
+}
 NodeLocationAccessors
 NodeIntrospection::GetLocations(clang::DynTypedNode const &) {
   return {};
 }
 } // namespace tooling
 } // namespace clang

clang/unittests/Introspection/IntrospectionTest.cpp

)cpp",
 
   // clang-format off
   std::vector<std::pair<std::string, SourceLocation>> ActualLocations{
 STRING_LOCATION_STDPAIR(MethodDecl, getBeginLoc()),
 STRING_LOCATION_STDPAIR(MethodDecl, getBodyRBrace()),
 STRING_LOCATION_STDPAIR(MethodDecl, getEndLoc()),
 STRING_LOCATION_STDPAIR(MethodDecl, getInnerLocStart()),
 STRING_LOCATION_STDPAIR(MethodDecl, getLocation()),
+STRING_LOCATION_STDPAIR(MethodDecl, getNameInfo().getBeginLoc()),
+STRING_LOCATION_STDPAIR(MethodDecl, getNameInfo().getEndLoc()),
+STRING_LOCATION_STDPAIR(MethodDecl, getNameInfo().getLoc()),
 STRING_LOCATION_STDPAIR(MethodDecl, getOuterLocStart()),
 STRING_LOCATION_STDPAIR(MethodDecl, getQualifierLoc().getBeginLoc()),
 STRING_LOCATION_STDPAIR(MethodDecl, getQualifierLoc().getEndLoc()),
 STRING_LOCATION_STDPAIR(MethodDecl, getQualifierLoc().getLocalBeginLoc()),
 STRING_LOCATION_STDPAIR(MethodDecl, getQualifierLoc().getLocalEndLoc()),
 STRING_LOCATION_STDPAIR(MethodDecl, getQualifierLoc().getPrefix().getBeginLoc()),
 STRING_LOCATION_STDPAIR(MethodDecl, getQualifierLoc().getPrefix().getEndLoc()),
 STRING_LOCATION_STDPAIR(MethodDecl, getQualifierLoc().getPrefix().getLocalBeginLoc()),
llvm::sort(ExpectedRanges, [](const auto &LHS, const auto &RHS) {
     return LHS.first < RHS.first;
   });
 
   // clang-format off
   EXPECT_EQ(
             llvm::makeArrayRef(ExpectedRanges),
       (ArrayRef<std::pair<std::string, SourceRange>>{
 STRING_LOCATION_STDPAIR(MethodDecl, getExceptionSpecSourceRange()),
+STRING_LOCATION_STDPAIR(MethodDecl, getNameInfo().getSourceRange()),
 STRING_LOCATION_STDPAIR(MethodDecl, getParametersSourceRange()),
 STRING_LOCATION_STDPAIR(MethodDecl, getQualifierLoc().getLocalSourceRange()),
 STRING_LOCATION_STDPAIR(MethodDecl, getQualifierLoc().getPrefix().getLocalSourceRange()),
 STRING_LOCATION_STDPAIR(MethodDecl, getQualifierLoc().getPrefix().getPrefix().getLocalSourceRange()),
 STRING_LOCATION_STDPAIR(MethodDecl, getQualifierLoc().getPrefix().getPrefix().getPrefix().getLocalSourceRange()),
 STRING_LOCATION_STDPAIR(MethodDecl, getQualifierLoc().getPrefix().getPrefix().getPrefix().getSourceRange()),
 STRING_LOCATION_STDPAIR(MethodDecl, getQualifierLoc().getPrefix().getPrefix().getSourceRange()),
 STRING_LOCATION_STDPAIR(MethodDecl, getQualifierLoc().getPrefix().getSourceRange()),
)cpp",
   EXPECT_THAT(ExpectedRanges,
               UnorderedElementsAre(
                   STRING_LOCATION_PAIR(TL, getLocalSourceRange()),
                   STRING_LOCATION_PAIR(TL, getSourceRange()),
                   STRING_LOCATION_PAIR(
                       TL, getAs<clang::TypeOfExprTypeLoc>().getParensRange())));
 }
 #endif
+
+TEST(Introspection, SourceLocations_DeclarationNameInfo_Dtor) {
+  if (!NodeIntrospection::hasIntrospectionSupport())
+    return;
+  auto AST =
+      buildASTFromCode(R"cpp(
+class Foo
+{
+  ~Foo() {}
+};
+)cpp",
+                       "foo.cpp", std::make_shared<PCHContainerOperations>());
+  auto &Ctx = AST->getASTContext();
+  auto &TU = *Ctx.getTranslationUnitDecl();
+
+  auto BoundNodes = ast_matchers::match(
+      decl(hasDescendant(cxxDestructorDecl(hasName("~Foo")).bind("dtor"))), TU,
+      Ctx);
+
+  EXPECT_EQ(BoundNodes.size(), 1u);
+
+  const auto *Dtor = BoundNodes[0].getNodeAs<CXXDestructorDecl>("dtor");
+  auto NI = Dtor->getNameInfo();
+  auto Result = NodeIntrospection::GetLocations(NI);
+
+  auto ExpectedLocations =
+      FormatExpected<SourceLocation>(Result.LocationAccessors);
+
+  llvm::sort(ExpectedLocations);
+
+  // clang-format off
+  EXPECT_EQ(
+      llvm::makeArrayRef(ExpectedLocations),
+      (ArrayRef<std::pair<std::string, SourceLocation>>{
+          STRING_LOCATION_STDPAIR((&NI), getBeginLoc()),
+          STRING_LOCATION_STDPAIR((&NI), getEndLoc()),
+          STRING_LOCATION_STDPAIR((&NI), getLoc()),
+          STRING_LOCATION_STDPAIR((&NI),
+getNamedTypeInfo()->getTypeLoc().getAs<clang::TypeSpecTypeLoc>().getNameLoc()),
+          STRING_LOCATION_STDPAIR(
+              (&NI), getNamedTypeInfo()->getTypeLoc().getBeginLoc()),
+          STRING_LOCATION_STDPAIR(
+              (&NI), getNamedTypeInfo()->getTypeLoc().getEndLoc())}));
+  // clang-format on
+
+  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);
+
+  EXPECT_THAT(
+      ExpectedRanges,
+      UnorderedElementsAre(
+          STRING_LOCATION_PAIR(
+              (&NI), getNamedTypeInfo()->getTypeLoc().getLocalSourceRange()),
+          STRING_LOCATION_PAIR(
+              (&NI), getNamedTypeInfo()->getTypeLoc().getSourceRange()),
+          STRING_LOCATION_PAIR((&NI), getSourceRange())));
+}
+
+TEST(Introspection, SourceLocations_DeclarationNameInfo_ConvOp) {
+  if (!NodeIntrospection::hasIntrospectionSupport())
+    return;
+  auto AST =
+      buildASTFromCode(R"cpp(
+class Foo
+{
+  bool operator==(const Foo&) const { return false; }
+};
+)cpp",
+                       "foo.cpp", std::make_shared<PCHContainerOperations>());
+  auto &Ctx = AST->getASTContext();
+  auto &TU = *Ctx.getTranslationUnitDecl();
+
+  auto BoundNodes = ast_matchers::match(
+      decl(hasDescendant(cxxMethodDecl().bind("opeq"))), TU, Ctx);
+
+  EXPECT_EQ(BoundNodes.size(), 1u);
+
+  const auto *Opeq = BoundNodes[0].getNodeAs<CXXMethodDecl>("opeq");
+  auto NI = Opeq->getNameInfo();
+  auto Result = NodeIntrospection::GetLocations(NI);
+
+  auto ExpectedLocations =
+      FormatExpected<SourceLocation>(Result.LocationAccessors);
+
+  llvm::sort(ExpectedLocations);
+
+  EXPECT_EQ(llvm::makeArrayRef(ExpectedLocations),
+            (ArrayRef<std::pair<std::string, SourceLocation>>{
+                STRING_LOCATION_STDPAIR((&NI), getBeginLoc()),
+                STRING_LOCATION_STDPAIR((&NI), getEndLoc()),
+                STRING_LOCATION_STDPAIR((&NI), getLoc())}));
+
+  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);
+
+  EXPECT_THAT(ExpectedRanges,
+              UnorderedElementsAre(
+                  STRING_LOCATION_PAIR((&NI), getSourceRange()),
+                  STRING_LOCATION_PAIR((&NI), getCXXOperatorNameRange())));
+}
+
+TEST(Introspection, SourceLocations_DeclarationNameInfo_LitOp) {
+  if (!NodeIntrospection::hasIntrospectionSupport())
+    return;
+  auto AST =
+      buildASTFromCode(R"cpp(
+long double operator"" _identity ( long double val )
+{
+    return val;
+}
+)cpp",
+                       "foo.cpp", std::make_shared<PCHContainerOperations>());
+  auto &Ctx = AST->getASTContext();
+  auto &TU = *Ctx.getTranslationUnitDecl();
+
+  auto BoundNodes = ast_matchers::match(
+      decl(hasDescendant(functionDecl().bind("litop"))), TU, Ctx);
+
+  EXPECT_EQ(BoundNodes.size(), 1u);
+
+  const auto *LitOp = BoundNodes[0].getNodeAs<FunctionDecl>("litop");
+  auto NI = LitOp->getNameInfo();
+  auto Result = NodeIntrospection::GetLocations(NI);
+
+  auto ExpectedLocations =
+      FormatExpected<SourceLocation>(Result.LocationAccessors);
+
+  llvm::sort(ExpectedLocations);
+
+  EXPECT_EQ(llvm::makeArrayRef(ExpectedLocations),
+            (ArrayRef<std::pair<std::string, SourceLocation>>{
+                STRING_LOCATION_STDPAIR((&NI), getBeginLoc()),
+                STRING_LOCATION_STDPAIR((&NI), getCXXLiteralOperatorNameLoc()),
+                STRING_LOCATION_STDPAIR((&NI), getEndLoc()),
+                STRING_LOCATION_STDPAIR((&NI), getLoc())}));
+
+  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);
+
+  EXPECT_THAT(ExpectedRanges, UnorderedElementsAre(STRING_LOCATION_PAIR(
+                                  (&NI), getSourceRange())));
+}