Add srcloc output to clang-query

[aaron.ballman]

Thank you for this, it looks really useful!

clang-tools-extra/clang-query/Query.cpp

92

95

It should be named Locs per the usual coding conventions.

(I'll hold my nose on the use of auto here, but if it got spelled out since you're touching the line anyway, that would not be a terrible thing.)

97

it -> Iter

104

SourceLocations -> source locations ?

106

CommonLoc and the type should definitely be spelled out.

107

Scout

121

it -> Iter

134

SourceRanges -> source ranges ?

137–138

Same here as above.

Given how common this code seems to be with the first block of code, would it make sense to turn some of this code into a lambda?

150

it -> Iter

163

SourceRange -> source range ?

166–167

More names to correct for conventions. Can you also spell out at least the location datatype?

[steveire]

Update

[steveire]

Update

[steveire]

@aaron.ballman ping?

[steveire]

Update

[njames93]

clang-tools-extra/clang-query/Query.cpp

106–108

nit: Elide braces.

122

Can this be brought out the loop and re-used for each of the 3 loops?

clang-tools-extra/clang-query/QueryParser.cpp

128

Can worry about detecting Introspection support in a follow-up

[aaron.ballman]

LGTM aside from the nits from @njames93 and I.

clang-tools-extra/clang-query/Query.cpp

96

clang-tools-extra/clang-query/CMakeLists.txt

 
 clang_target_link_libraries(clangQuery
   PRIVATE
   clangAST
   clangASTMatchers
   clangBasic
   clangDynamicASTMatchers
   clangFrontend
+  clangTooling
   clangSerialization
   )
 
 add_subdirectory(tool)

clang-tools-extra/clang-query/Query.h

 #include "clang/ASTMatchers/Dynamic/VariantValue.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/Optional.h"
 #include <string>
 
 namespace clang {
 namespace query {
 
-enum OutputKind { OK_Diag, OK_Print, OK_DetailedAST };
+enum OutputKind { OK_Diag, OK_Print, OK_DetailedAST, OK_SrcLoc };
 
 enum QueryKind {
   QK_Invalid,
   QK_NoOp,
   QK_Help,
   QK_Let,
   QK_Match,
   QK_SetBool,

clang-tools-extra/clang-query/Query.cpp

 //===---- Query.cpp - clang-query query -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Query.h"
 #include "QuerySession.h"
 #include "clang/AST/ASTDumper.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/TextDiagnostic.h"
+#include "clang/Tooling/NodeIntrospection.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang::ast_matchers;
 using namespace clang::ast_matchers::dynamic;
 
 namespace clang {
 namespace query {
 
OS << "Available commands:\n\n"
         "Several commands accept a <feature> parameter. The available features "
         "are:\n\n"
         "  print                             "
         "Pretty-print bound nodes.\n"
         "  diag                              "
         "Diagnostic location for bound nodes.\n"
         "  detailed-ast                      "
         "Detailed AST output for bound nodes.\n"
+        "  srcloc                            "
+        "Source locations and ranges for bound nodes.\n"
         "  dump                              "
         "Detailed AST output for bound nodes (alias of detailed-ast).\n\n";
   return true;
 }
 
 bool QuitQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
   QS.Terminate = true;
   return true;
 }
 
 namespace {
 
 struct CollectBoundNodes : MatchFinder::MatchCallback {
   std::vector<BoundNodes> &Bindings;
   CollectBoundNodes(std::vector<BoundNodes> &Bindings) : Bindings(Bindings) {}
   void run(const MatchFinder::MatchResult &Result) override {
     Bindings.push_back(Result.Nodes);
   }
 };
 
+void dumpLocations(llvm::raw_ostream &OS, DynTypedNode Node, ASTContext &Ctx,
+                   const DiagnosticsEngine &Diags, SourceManager const &SM) {
+  auto Locs = clang::tooling::NodeIntrospection::GetLocations(Node);
+
+  auto PrintLocations = [](llvm::raw_ostream &OS, auto Iter, auto End) {
+    auto CommonEntry = Iter->first;
+    auto Scout = Iter;
+    SmallVector<std::string> LocationStrings;
+    while (Scout->first == CommonEntry) {
+      LocationStrings.push_back(
+          tooling::LocationCallFormatterCpp::format(*Iter->second));
+      if (Scout == End)
+        break;
+      ++Scout;
+      if (Scout->first == CommonEntry)
+        ++Iter;
+    }
+    llvm::sort(LocationStrings);
+    for (auto &LS : LocationStrings) {
+      OS << " * \"" << LS << "\"\n";
+    }
+    return Iter;
+  };
+
+  TextDiagnostic TD(OS, Ctx.getLangOpts(), &Diags.getDiagnosticOptions());
+
+  for (auto Iter = Locs.LocationAccessors.begin();
+       Iter != Locs.LocationAccessors.end(); ++Iter) {
+    if (!Iter->first.isValid())
+      continue;
+
+    TD.emitDiagnostic(FullSourceLoc(Iter->first, SM), DiagnosticsEngine::Note,
+                      "source locations here", None, None);
+
+    Iter = PrintLocations(OS, Iter, Locs.LocationAccessors.end());
+    OS << '\n';
+  }
+
+  for (auto Iter = Locs.RangeAccessors.begin();
+       Iter != Locs.RangeAccessors.end(); ++Iter) {
+
+    if (!Iter->first.getBegin().isValid())
+      continue;
+
+    if (SM.getPresumedLineNumber(Iter->first.getBegin()) !=
+        SM.getPresumedLineNumber(Iter->first.getEnd()))
+      continue;
+
+    TD.emitDiagnostic(FullSourceLoc(Iter->first.getBegin(), SM),
+                      DiagnosticsEngine::Note,
+                      "source ranges here " + Iter->first.printToString(SM),
+                      CharSourceRange::getTokenRange(Iter->first), None);
+
+    Iter = PrintLocations(OS, Iter, Locs.RangeAccessors.end());
+  }
+  for (auto Iter = Locs.RangeAccessors.begin();
+       Iter != Locs.RangeAccessors.end(); ++Iter) {
+
+    if (!Iter->first.getBegin().isValid())
+      continue;
+
+    if (SM.getPresumedLineNumber(Iter->first.getBegin()) ==
+        SM.getPresumedLineNumber(Iter->first.getEnd()))
+      continue;
+
+    TD.emitDiagnostic(
+        FullSourceLoc(Iter->first.getBegin(), SM), DiagnosticsEngine::Note,
+        "source range " + Iter->first.printToString(SM) + " starting here...",
+        CharSourceRange::getTokenRange(Iter->first), None);
+
+    auto ColNum = SM.getPresumedColumnNumber(Iter->first.getEnd());
+    auto LastLineLoc = Iter->first.getEnd().getLocWithOffset(-(ColNum - 1));
+
+    TD.emitDiagnostic(FullSourceLoc(Iter->first.getEnd(), SM),
+                      DiagnosticsEngine::Note, "... ending here",
+                      CharSourceRange::getTokenRange(
+                          SourceRange(LastLineLoc, Iter->first.getEnd())),
+                      None);
+
+    Iter = PrintLocations(OS, Iter, Locs.RangeAccessors.end());
+  }
+  OS << "\n";
+}
+
 } // namespace
 
 bool MatchQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
   unsigned MatchCount = 0;
 
   for (auto &AST : QS.ASTs) {
     MatchFinder Finder;
     std::vector<BoundNodes> Matches;
     DynTypedMatcher MaybeBoundMatcher = Matcher;
     if (QS.BindRoot) {
       llvm::Optional<DynTypedMatcher> M = Matcher.tryBind("root");
       if (M)
         MaybeBoundMatcher = *M;
     }
     CollectBoundNodes Collect(Matches);
     if (!Finder.addDynamicMatcher(MaybeBoundMatcher, &Collect)) {
       OS << "Not a valid top-level matcher.\n";
       return false;
     }
 
-    AST->getASTContext().getParentMapContext().setTraversalKind(QS.TK);
-    Finder.matchAST(AST->getASTContext());
+    auto &Ctx = AST->getASTContext();
+    const auto &SM = Ctx.getSourceManager();
+    Ctx.getParentMapContext().setTraversalKind(QS.TK);
+    Finder.matchAST(Ctx);
 
     if (QS.PrintMatcher) {
       SmallVector<StringRef, 4> Lines;
       Source.split(Lines, "\n");
       auto FirstLine = Lines[0];
       Lines.erase(Lines.begin(), Lines.begin() + 1);
       while (!Lines.empty() && Lines.back().empty()) {
         Lines.resize(Lines.size() - 1);
for (auto MI = Matches.begin(), ME = Matches.end(); MI != ME; ++MI) {
         if (QS.DetailedASTOutput) {
           OS << "Binding for \"" << BI->first << "\":\n";
           const ASTContext &Ctx = AST->getASTContext();
           ASTDumper Dumper(OS, Ctx, AST->getDiagnostics().getShowColors());
           Dumper.SetTraversalKind(QS.TK);
           Dumper.Visit(BI->second);
           OS << "\n";
         }
+        if (QS.SrcLocOutput) {
+          OS << "\n  \"" << BI->first << "\" Source locations\n";
+          OS << "  " << std::string(19 + BI->first.size(), '-') << '\n';
+
+          dumpLocations(OS, BI->second, Ctx, AST->getDiagnostics(), SM);
+          OS << "\n";
+        }
       }
 
       if (MI->getMap().empty())
         OS << "No bindings.\n";
     }
   }
 
   OS << MatchCount << (MatchCount == 1 ? " match.\n" : " matches.\n");

clang-tools-extra/clang-query/QueryParser.cpp

 }
 
 template <typename QueryType> QueryRef QueryParser::parseSetOutputKind() {
   StringRef ValStr;
   unsigned OutKind = LexOrCompleteWord<unsigned>(this, ValStr)
                          .Case("diag", OK_Diag)
                          .Case("print", OK_Print)
                          .Case("detailed-ast", OK_DetailedAST)
+                         .Case("srcloc", OK_SrcLoc)
                          .Case("dump", OK_DetailedAST)
                          .Default(~0u);
   if (OutKind == ~0u) {
     return new InvalidQuery(
         "expected 'diag', 'print', 'detailed-ast' or 'dump', got '" + ValStr +
         "'");
   }
 
   switch (OutKind) {
   case OK_DetailedAST:
     return new QueryType(&QuerySession::DetailedASTOutput);
   case OK_Diag:
     return new QueryType(&QuerySession::DiagOutput);
   case OK_Print:
     return new QueryType(&QuerySession::PrintOutput);
+  case OK_SrcLoc:
+    return new QueryType(&QuerySession::SrcLocOutput);
   }
 
   llvm_unreachable("Invalid output kind");
 }
 
 QueryRef QueryParser::parseSetTraversalKind(TraversalKind QuerySession::*Var) {
   StringRef ValStr;
   unsigned Value =

clang-tools-extra/clang-query/QuerySession.h

 
 namespace query {
 
 /// Represents the state for a particular clang-query session.
 class QuerySession {
 public:
   QuerySession(llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs)
       : ASTs(ASTs), PrintOutput(false), DiagOutput(true),
-        DetailedASTOutput(false), BindRoot(true), PrintMatcher(false),
-        Terminate(false), TK(TK_AsIs) {}
+        DetailedASTOutput(false), SrcLocOutput(false), BindRoot(true),
+        PrintMatcher(false), Terminate(false), TK(TK_AsIs) {}
 
   llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs;
 
   bool PrintOutput;
   bool DiagOutput;
   bool DetailedASTOutput;
+  bool SrcLocOutput;
 
   bool BindRoot;
   bool PrintMatcher;
   bool Terminate;
 
   TraversalKind TK;
   llvm::StringMap<ast_matchers::dynamic::VariantValue> NamedValues;
 };
 
 } // namespace query
 } // namespace clang
 
 #endif

clang-tools-extra/unittests/clang-query/QueryParserTest.cpp

TEST_F(QueryParserTest, Complete) {
   EXPECT_EQ("traversal", Comps[0].DisplayText);
 
   Comps = QueryParser::complete("enable ", 7, QS);
   ASSERT_EQ(1u, Comps.size());
   EXPECT_EQ("output ", Comps[0].TypedText);
   EXPECT_EQ("output", Comps[0].DisplayText);
 
   Comps = QueryParser::complete("enable output ", 14, QS);
-  ASSERT_EQ(4u, Comps.size());
+  ASSERT_EQ(5u, Comps.size());
 
   EXPECT_EQ("diag ", Comps[0].TypedText);
   EXPECT_EQ("diag", Comps[0].DisplayText);
   EXPECT_EQ("print ", Comps[1].TypedText);
   EXPECT_EQ("print", Comps[1].DisplayText);
   EXPECT_EQ("detailed-ast ", Comps[2].TypedText);
   EXPECT_EQ("detailed-ast", Comps[2].DisplayText);
-  EXPECT_EQ("dump ", Comps[3].TypedText);
-  EXPECT_EQ("dump", Comps[3].DisplayText);
+  EXPECT_EQ("srcloc ", Comps[3].TypedText);
+  EXPECT_EQ("srcloc", Comps[3].DisplayText);
+  EXPECT_EQ("dump ", Comps[4].TypedText);
+  EXPECT_EQ("dump", Comps[4].DisplayText);
 
   Comps = QueryParser::complete("set traversal ", 14, QS);
   ASSERT_EQ(2u, Comps.size());
 
   EXPECT_EQ("AsIs ", Comps[0].TypedText);
   EXPECT_EQ("AsIs", Comps[0].DisplayText);
   EXPECT_EQ("IgnoreUnlessSpelledInSource ", Comps[1].TypedText);
   EXPECT_EQ("IgnoreUnlessSpelledInSource", Comps[1].DisplayText);