[clang-extdef-mapping] Allow clang-extdef-mapping tool to output customized filename for each index entry

[OikawaKirie]

Summary

The clang-extdef-mapping tool can only output the real file name of the input source file. When analyzing with AST file based CTU analysis, the file name should be adjusted to the corresponding AST file, where .ast will be appended to the file name, and sometimes the path will even be changed. It is very inconvenient to adjust the file path with such a separated step, especially on Windows, where utility tools such as sed are not available.

This patch uses Regex::sub function to adjust the output file name for each index entry with the pattern provided by the user.

[OikawaKirie]

ping

[steakhal]

I'm not against the idea.
However, the implementation seems to be quite complicated, compared to what it's actually doing.
Can't we spare the heap allocation somehow? It doesn't seem necessary to me.

clang/test/Analysis/func-mapping-path.c

+// RUN: %clang_extdef_map %s -m '^(.*)clang(.*)$' -r '\1ctu-dir\2.ast' -- | FileCheck %s
+// CHECK: {{ctu-dir.*func-mapping-path\.c\.ast}}
+void f() {}

clang/tools/clang-extdef-mapping/ClangExtDefMapGen.cpp

 #include <string>
 
 using namespace llvm;
 using namespace clang;
 using namespace clang::cross_tu;
 using namespace clang::tooling;
 
 static cl::OptionCategory ClangExtDefMapGenCategory("clang-extdefmapgen options");
+static cl::opt<std::string> OutputPathAdjusterMatcher(
+    "m", cl::desc("Match the part of output path to be replaced with regex"),
+    cl::cat(ClangExtDefMapGenCategory));
+static cl::opt<std::string> OutputPathAdjusterNewPath(
+    "r", cl::desc("The string which matched pattern will be replaced to"),
+    cl::cat(ClangExtDefMapGenCategory));
+
+namespace {
+class OutputPathAdjuster {
+  Regex Matcher;
+  std::string NewPath;
+
+public:
+  std::string adjust(StringRef Path) const {
+    return Matcher.sub(NewPath, Path);
+  }
+
+  bool resetMatcher(StringRef MatcherStr, StringRef NewPathStr);
+};
+
+bool OutputPathAdjuster::resetMatcher(StringRef MatcherStr,
+                                      StringRef NewPathStr) {
+  std::string ErrMsg;
+  Regex MatcherRegex(MatcherStr);
+  if (!MatcherRegex.isValid(ErrMsg)) {
+    errs() << "Invalid adjuster template: " << ErrMsg << '\n';
+    return false;
+  }
+
+  Matcher = std::move(MatcherRegex);
+  NewPath = NewPathStr.str();
+  return true;
+}
+} // namespace
 
 class MapExtDefNamesConsumer : public ASTConsumer {
 public:
-  MapExtDefNamesConsumer(ASTContext &Context)
-      : Ctx(Context), SM(Context.getSourceManager()) {}
+  MapExtDefNamesConsumer(const OutputPathAdjuster *Adjuster)
+      : Adjuster(Adjuster) {}
 
   ~MapExtDefNamesConsumer() {
     // Flush results to standard output.
     llvm::outs() << createCrossTUIndexString(Index);
   }
 
   void HandleTranslationUnit(ASTContext &Context) override {
     handleDecl(Context.getTranslationUnitDecl());
   }
 
 private:
   void handleDecl(const Decl *D);
   void addIfInMain(const DeclaratorDecl *DD, SourceLocation defStart);
 
-  ASTContext &Ctx;
-  SourceManager &SM;
   llvm::StringMap<std::string> Index;
   std::string CurrentFileName;
+  const OutputPathAdjuster *Adjuster = nullptr;
 };
 
 void MapExtDefNamesConsumer::handleDecl(const Decl *D) {
   if (!D)
     return;
 
   if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
     if (FD->isThisDeclarationADefinition())
       if (const Stmt *Body = FD->getBody())
         addIfInMain(FD, Body->getBeginLoc());
   } else if (const auto *VD = dyn_cast<VarDecl>(D)) {
-    if (cross_tu::containsConst(VD, Ctx) && VD->hasInit())
+    if (cross_tu::containsConst(VD, VD->getASTContext()) && VD->hasInit())
       if (const Expr *Init = VD->getInit())
         addIfInMain(VD, Init->getBeginLoc());
   }
 
   if (const auto *DC = dyn_cast<DeclContext>(D))
     for (const Decl *D : DC->decls())
       handleDecl(D);
 }
 
 void MapExtDefNamesConsumer::addIfInMain(const DeclaratorDecl *DD,
                                          SourceLocation defStart) {
   llvm::Optional<std::string> LookupName =
       CrossTranslationUnitContext::getLookupName(DD);
   if (!LookupName)
     return;
   assert(!LookupName->empty() && "Lookup name should be non-empty.");
 
+  SourceManager &SM = DD->getASTContext().getSourceManager();
   if (CurrentFileName.empty()) {
     CurrentFileName = std::string(
         SM.getFileEntryForID(SM.getMainFileID())->tryGetRealPathName());
+    if (Adjuster)
+      CurrentFileName = Adjuster->adjust(CurrentFileName);
     if (CurrentFileName.empty())
       CurrentFileName = "invalid_file";
   }
 
   switch (DD->getLinkageInternal()) {
   case ExternalLinkage:
   case VisibleNoLinkage:
   case UniqueExternalLinkage:
     if (SM.isInMainFile(defStart))
       Index[*LookupName] = CurrentFileName;
     break;
   default:
     break;
   }
 }
 
-class MapExtDefNamesAction : public ASTFrontendAction {
-protected:
-  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
-                                                 llvm::StringRef) override {
-    return std::make_unique<MapExtDefNamesConsumer>(CI.getASTContext());
+class MapExtDefNamesConsumerFactory {
+  const OutputPathAdjuster *Adjuster = nullptr;
+
+public:
+  MapExtDefNamesConsumerFactory(const OutputPathAdjuster *Adjuster)
+      : Adjuster(Adjuster) {}
+
+  std::unique_ptr<ASTConsumer> newASTConsumer() {
+    return std::make_unique<MapExtDefNamesConsumer>(Adjuster);
   }
 };
 
 static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
 
 int main(int argc, const char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv[0], false);
   PrettyStackTraceProgram X(argc, argv);
 
   const char *Overview = "\nThis tool collects the USR name and location "
                          "of external definitions in the source files "
-                         "(excluding headers).\n";
+                         "(excluding headers).\n\nReset output path with -m "
+                         "<regex> -r <new-path>.\n";
   auto ExpectedParser = CommonOptionsParser::create(
       argc, argv, ClangExtDefMapGenCategory, cl::ZeroOrMore, Overview);
   if (!ExpectedParser) {
     llvm::errs() << ExpectedParser.takeError();
     return 1;
   }
   CommonOptionsParser &OptionsParser = ExpectedParser.get();
 
+  std::unique_ptr<OutputPathAdjuster> Adjuster;
+  if (!OutputPathAdjusterMatcher.empty()) {
+    Adjuster = std::make_unique<OutputPathAdjuster>();
+    if (!Adjuster->resetMatcher(OutputPathAdjusterMatcher,
+                                OutputPathAdjusterNewPath))
+      return 1;
+  }
+
   ClangTool Tool(OptionsParser.getCompilations(),
                  OptionsParser.getSourcePathList());
 
-  return Tool.run(newFrontendActionFactory<MapExtDefNamesAction>().get());
+  MapExtDefNamesConsumerFactory Factory(Adjuster.get());
+  return Tool.run(newFrontendActionFactory(&Factory).get());
 }