Add srcloc output to clang-query

[aaron.ballman]

Thank you for this, it looks really useful!

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

94

97

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.)

99

it -> Iter

106

SourceLocations -> source locations ?

108

CommonLoc and the type should definitely be spelled out.

109

Scout

123

it -> Iter

136

SourceRanges -> source ranges ?

139–140

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?

152

it -> Iter

165

SourceRange -> source range ?

168–169

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

108–110

nit: Elide braces.

124

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

98

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/NodeLocationIntrospection.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, ast_type_traits::DynTypedNode node,
+                   ASTContext &Ctx, const DiagnosticsEngine &Diags,
+                   SourceManager const &SM) {
+  auto locs = clang::tooling::NodeLocationIntrospection::GetLocations(node);
+
+  for (auto it = locs.LocationAccessors.begin();
+       it != locs.LocationAccessors.end(); ++it) {
+    if (!it->first.isValid())
+      continue;
+
+    TextDiagnostic TD(OS, Ctx.getLangOpts(), &Diags.getDiagnosticOptions());
+    TD.emitDiagnostic(FullSourceLoc(it->first, SM), DiagnosticsEngine::Note,
+                      "SourceLocations here", None, None);
+
+    auto commonLoc = it->first;
+    auto scout = it;
+    while (scout->first == commonLoc) {
+      OS << " * "
+         << "\"" + it->second + "()\"\n";
+      if (scout == locs.LocationAccessors.end())
+        break;
+      ++scout;
+      if (scout->first == commonLoc) {
+        ++it;
+      }
+    }
+    OS << '\n';
+  }
+
+  for (auto it = locs.RangeAccessors.begin(); it != locs.RangeAccessors.end();
+       ++it) {
+
+    if (!it->first.getBegin().isValid())
+      continue;
+
+    if (SM.getPresumedLineNumber(it->first.getBegin()) !=
+        SM.getPresumedLineNumber(it->first.getEnd()))
+      continue;
+
+    TextDiagnostic TD(OS, Ctx.getLangOpts(), &Diags.getDiagnosticOptions());
+    TD.emitDiagnostic(FullSourceLoc(it->first.getBegin(), SM),
+                      DiagnosticsEngine::Note,
+                      "SourceRanges here " + it->first.printToString(SM),
+                      CharSourceRange::getTokenRange(it->first), None);
+
+    auto commonLoc = it->first;
+    auto scout = it;
+    while (scout->first == commonLoc) {
+      OS << " * "
+         << "\"" + it->second + "()\"\n";
+      if (scout == locs.RangeAccessors.end())
+        break;
+      ++scout;
+      if (scout->first == commonLoc) {
+        ++it;
+      }
+    }
+  }
+  for (auto it = locs.RangeAccessors.begin(); it != locs.RangeAccessors.end();
+       ++it) {
+
+    if (!it->first.getBegin().isValid())
+      continue;
+
+    if (SM.getPresumedLineNumber(it->first.getBegin()) ==
+        SM.getPresumedLineNumber(it->first.getEnd()))
+      continue;
+
+    TextDiagnostic TD(OS, Ctx.getLangOpts(), &Diags.getDiagnosticOptions());
+    TD.emitDiagnostic(
+        FullSourceLoc(it->first.getBegin(), SM), DiagnosticsEngine::Note,
+        "SourceRange " + it->first.printToString(SM) + " starting here...",
+        CharSourceRange::getTokenRange(it->first), None);
+
+    auto colNum = SM.getPresumedColumnNumber(it->first.getEnd());
+    auto lastLineLoc = it->first.getEnd().getLocWithOffset(-(colNum - 1));
+
+    TD.emitDiagnostic(FullSourceLoc(it->first.getEnd(), SM),
+                      DiagnosticsEngine::Note, "... ending here",
+                      CharSourceRange::getTokenRange(
+                          SourceRange(lastLineLoc, it->first.getEnd())),
+                      None);
+
+    auto commonLoc = it->first;
+    auto scout = it;
+    while (scout->first == commonLoc) {
+      OS << " * "
+         << "\"" + it->second + "()\"\n";
+      if (scout == locs.RangeAccessors.end())
+        break;
+      ++scout;
+      if (scout->first == commonLoc) {
+        ++it;
+      }
+    }
+  }
+  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.PrintOutput) {
           OS << "Binding for \"" << BI->first << "\":\n";
           BI->second.print(OS, AST->getASTContext().getPrintingPolicy());
           OS << "\n";
         }
         if (QS.DetailedASTOutput) {
           OS << "Binding for \"" << BI->first << "\":\n";
-          const ASTContext &Ctx = AST->getASTContext();
-          const SourceManager &SM = Ctx.getSourceManager();
           ASTDumper Dumper(OS, Ctx, SM.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(
     ast_type_traits::TraversalKind QuerySession::*Var) {
   StringRef ValStr;

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(ast_type_traits::TK_AsIs) {}
+        DetailedASTOutput(false), SrcLocOutput(false), BindRoot(true),
+        PrintMatcher(false), Terminate(false), TK(ast_type_traits::TK_AsIs) {}
 
   llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs;
 
   bool PrintOutput;
   bool DiagOutput;
   bool DetailedASTOutput;
+  bool SrcLocOutput;
 
   bool BindRoot;
   bool PrintMatcher;
   bool Terminate;
 
   ast_type_traits::TraversalKind TK;
   llvm::StringMap<ast_matchers::dynamic::VariantValue> NamedValues;
 };
 
 } // namespace query
 } // namespace clang
 
 #endif