[AST] Add introspection support for Decls

[steveire]

Summary

The test code has lots of interesting locations which are not yet
introspected, but those will come later:

http://ce.steveire.com/z/3T90hR

[steveire]

Update

[steveire]

Update

[steveire]

Update

clang/include/clang/Tooling/NodeIntrospection.h

 #include "clang/AST/DeclarationName.h"
 
 #include <memory>
 #include <set>
 
 namespace clang {
 
 class Stmt;
+class Decl;
 
 namespace tooling {
 
 class LocationCall {
 public:
   enum LocationCallFlags { NoFlags, ReturnsPointer, IsCast };
   LocationCall(std::shared_ptr<LocationCall> on, std::string name,
                LocationCallFlags flags = NoFlags)

 
 struct NodeLocationAccessors {
   SourceLocationMap LocationAccessors;
   SourceRangeMap RangeAccessors;
 };
 
 namespace NodeIntrospection {
 NodeLocationAccessors GetLocations(clang::Stmt const *Object);
+NodeLocationAccessors GetLocations(clang::Decl const *Object);
 NodeLocationAccessors GetLocations(clang::DynTypedNode const &Node);
 } // namespace NodeIntrospection
 } // namespace tooling
 } // namespace clang
 #endif

clang/lib/Tooling/CMakeLists.txt

if (NOT Python3_EXECUTABLE
   file(GENERATE OUTPUT ${BINARY_INCLUDE_DIR}/NodeIntrospection.inc
     CONTENT "
 namespace clang {
 namespace tooling {
 
 NodeLocationAccessors NodeIntrospection::GetLocations(clang::Stmt const *) {
   return {};
 }
+NodeLocationAccessors NodeIntrospection::GetLocations(clang::Decl const *) {
+  return {};
+}
 NodeLocationAccessors
 NodeIntrospection::GetLocations(clang::DynTypedNode const &) {
   return {};
 }
 } // namespace tooling
 } // namespace clang
 "
     )

clang/lib/Tooling/DumpTool/ASTSrcLocProcessor.cpp

ASTSrcLocProcessor::ASTSrcLocProcessor(StringRef JsonPath)
   MatchFinder::MatchFinderOptions FinderOptions;
 
   Finder = std::make_unique<MatchFinder>(std::move(FinderOptions));
   Finder->addMatcher(
       cxxRecordDecl(
           isDefinition(),
           isSameOrDerivedFrom(
               // TODO: Extend this with other clades
-              namedDecl(hasName("clang::Stmt")).bind("nodeClade")),
+              namedDecl(hasAnyName("clang::Stmt", "clang::Decl"))
+                  .bind("nodeClade")),
           optionally(isDerivedFrom(cxxRecordDecl().bind("derivedFrom"))))
           .bind("className"),
       this);
 }
 
 std::unique_ptr<clang::ASTConsumer>
 ASTSrcLocProcessor::createASTConsumer(clang::CompilerInstance &Compiler,
                                       StringRef File) {

clang/lib/Tooling/DumpTool/generate_cxx_src_locs.py

if use_empty_implementation:
                   options.output_file), 'w') as f:
             f.write("""
 namespace clang {
 namespace tooling {
 
 NodeLocationAccessors NodeIntrospection::GetLocations(clang::Stmt const *) {
   return {};
 }
+NodeLocationAccessors NodeIntrospection::GetLocations(clang::Decl const *) {
+  return {};
+}
 NodeLocationAccessors
 NodeIntrospection::GetLocations(clang::DynTypedNode const &) {
   return {};
 }
 } // namespace tooling
 } // namespace clang
     """)
         sys.exit(0)

clang/unittests/Introspection/IntrospectionTest.cpp

llvm::transform(Accessors,
                         LocationCallFormatterCpp::format(Accessor.second.get()),
                         Accessor.first);
                   });
   return Result;
 }
 
 #define STRING_LOCATION_PAIR(INSTANCE, LOC) Pair(#LOC, INSTANCE->LOC)
 
-TEST(Introspection, SourceLocations) {
+TEST(Introspection, SourceLocations_Stmt) {
   auto AST = buildASTFromCode("void foo() {} void bar() { foo(); }", "foo.cpp",
                               std::make_shared<PCHContainerOperations>());
   auto &Ctx = AST->getASTContext();
   auto &TU = *Ctx.getTranslationUnitDecl();
 
   auto BoundNodes = ast_matchers::match(
       decl(hasDescendant(
           callExpr(callee(functionDecl(hasName("foo")))).bind("fooCall"))),
EXPECT_THAT(
                            STRING_LOCATION_PAIR(FooCall, getExprLoc()),
                            STRING_LOCATION_PAIR(FooCall, getRParenLoc())));
 
   auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);
 
   EXPECT_THAT(ExpectedRanges, UnorderedElementsAre(STRING_LOCATION_PAIR(
                                   FooCall, getSourceRange())));
 }
+
+TEST(Introspection, SourceLocations_Decl) {
+  auto AST =
+      buildASTFromCode(R"cpp(
+namespace ns1 {
+namespace ns2 {
+template <typename T, typename U> struct Foo {};
+template <typename T, typename U> struct Bar {
+  struct Nested {
+    template <typename A, typename B>
+    Foo<A, B> method(int i, bool b) const noexcept(true);
+  };
+};
+} // namespace ns2
+} // namespace ns1
+
+template <typename T, typename U>
+template <typename A, typename B>
+ns1::ns2::Foo<A, B> ns1::ns2::Bar<T, U>::Nested::method(int i, bool b) const
+    noexcept(true) {}
+)cpp",
+                       "foo.cpp", std::make_shared<PCHContainerOperations>());
+  auto &Ctx = AST->getASTContext();
+  auto &TU = *Ctx.getTranslationUnitDecl();
+
+  auto BoundNodes = ast_matchers::match(
+      decl(hasDescendant(
+          cxxMethodDecl(hasName("method")).bind("method"))),
+      TU, Ctx);
+
+  EXPECT_EQ(BoundNodes.size(), 1u);
+
+  const auto *MethodDecl = BoundNodes[0].getNodeAs<CXXMethodDecl>("method");
+
+  auto Result = NodeIntrospection::GetLocations(MethodDecl);
+
+  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
+    return;
+  }
+
+  auto ExpectedLocations =
+      FormatExpected<SourceLocation>(Result.LocationAccessors);
+
+  EXPECT_THAT(ExpectedLocations,
+              UnorderedElementsAre(
+                  STRING_LOCATION_PAIR(MethodDecl, getBeginLoc()),
+                  STRING_LOCATION_PAIR(MethodDecl, getBodyRBrace()),
+                  STRING_LOCATION_PAIR(MethodDecl, getEllipsisLoc()),
+                  STRING_LOCATION_PAIR(MethodDecl, getInnerLocStart()),
+                  STRING_LOCATION_PAIR(MethodDecl, getLocation()),
+                  STRING_LOCATION_PAIR(MethodDecl, getOuterLocStart()),
+                  STRING_LOCATION_PAIR(MethodDecl, getPointOfInstantiation()),
+                  STRING_LOCATION_PAIR(MethodDecl, getTypeSpecEndLoc()),
+                  STRING_LOCATION_PAIR(MethodDecl, getTypeSpecStartLoc()),
+                  STRING_LOCATION_PAIR(MethodDecl, getEndLoc())));
+
+  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);
+
+  EXPECT_THAT(
+      ExpectedRanges,
+      UnorderedElementsAre(
+          STRING_LOCATION_PAIR(MethodDecl, getExceptionSpecSourceRange()),
+          STRING_LOCATION_PAIR(MethodDecl, getParametersSourceRange()),
+          STRING_LOCATION_PAIR(MethodDecl, getReturnTypeSourceRange()),
+          STRING_LOCATION_PAIR(MethodDecl, getSourceRange())));
+}