Use CommonOptionsParser in clang-refactor

[arphaman]

Summary

This patch ensures that CommonOptionsParser works with subcommands. This allows clang-refactor to use the CommonOptionsParser.

Depends on https://reviews.llvm.org/D36574.

[ioeric]

Lgtm

lib/Tooling/CommonOptionsParser.cpp

for (CompileCommand &Command : Commands)
     for (const auto &Adjuster : Adjusters)
       Command.CommandLine = Adjuster(Command.CommandLine, Command.Filename);
   return Commands;
 }
 
 CommonOptionsParser::CommonOptionsParser(
     int &argc, const char **argv, cl::OptionCategory &Category,
     llvm::cl::NumOccurrencesFlag OccurrencesFlag, const char *Overview) {
-  static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden);
+  static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden,
+                            cl::sub(*cl::AllSubCommands));
 
   static cl::opt<std::string> BuildPath("p", cl::desc("Build path"),
-                                        cl::Optional, cl::cat(Category));
+                                        cl::Optional, cl::cat(Category),
+                                        cl::sub(*cl::AllSubCommands));
 
   static cl::list<std::string> SourcePaths(
       cl::Positional, cl::desc("<source0> [... <sourceN>]"), OccurrencesFlag,
-      cl::cat(Category));
+      cl::cat(Category), cl::sub(*cl::AllSubCommands));
 
   static cl::list<std::string> ArgsAfter(
       "extra-arg",
       cl::desc("Additional argument to append to the compiler command line"),
-      cl::cat(Category));
+      cl::cat(Category), cl::sub(*cl::AllSubCommands));
 
   static cl::list<std::string> ArgsBefore(
       "extra-arg-before",
       cl::desc("Additional argument to prepend to the compiler command line"),
-      cl::cat(Category));
+      cl::cat(Category), cl::sub(*cl::AllSubCommands));
 
   cl::HideUnrelatedOptions(Category);
 
   std::string ErrorMessage;
   Compilations =
       FixedCompilationDatabase::loadFromCommandLine(argc, argv, ErrorMessage);
   if (!Compilations && !ErrorMessage.empty())
     llvm::errs() << ErrorMessage;

test/Refactor/LocalRename/Field.cpp

-// RUN: clang-refactor local-rename -selection=test:%s -no-dbs %s | FileCheck %s
+// RUN: clang-refactor local-rename -selection=test:%s %s -- | FileCheck %s
 
 class Baz {
   int /*range=*/Foo; // CHECK: =*/Bar;
 public:
   Baz();
 };
 
 Baz::Baz() : /*range=*/Foo(0) {}  // CHECK: =*/Bar(0) {};

test/Refactor/tool-common-options.c

 // RUN: not clang-refactor 2>&1 | FileCheck --check-prefix=MISSING_ACTION %s
 // MISSING_ACTION: error: no refactoring action given
 // MISSING_ACTION-NEXT: note: the following actions are supported:
-
-// RUN: not clang-refactor local-rename -no-dbs 2>&1 | FileCheck --check-prefix=MISSING_SOURCES %s
-// MISSING_SOURCES: error: must provide paths to the source files when '-no-dbs' is used

tools/clang-refactor/ClangRefactor.cpp

 /// \file
 /// \brief This file implements a clang-refactor tool that performs various
 /// source transformations.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "TestSupport.h"
 #include "clang/Rewrite/Core/Rewriter.h"
+#include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Refactoring/RefactoringAction.h"
 #include "clang/Tooling/Refactoring/Rename/RenamingAction.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include <string>
 
 using namespace clang;
 using namespace tooling;
 using namespace refactor;
 namespace cl = llvm::cl;
 
 namespace opts {
 
 static cl::OptionCategory CommonRefactorOptions("Common refactoring options");
 
-static cl::opt<bool>
-    NoDatabases("no-dbs",
-                cl::desc("Ignore external databases including Clang's "
-                         "compilation database and indexer stores"),
-                cl::cat(CommonRefactorOptions), cl::sub(*cl::AllSubCommands));
-
 static cl::opt<bool> Verbose("v", cl::desc("Use verbose output"),
                              cl::cat(CommonRefactorOptions),
                              cl::sub(*cl::AllSubCommands));
 } // end namespace opts
 
 namespace {
 
 /// Stores the parsed `-selection` argument.

 /// A subcommand that corresponds to individual refactoring action.
 class RefactoringActionSubcommand : public cl::SubCommand {
 public:
   RefactoringActionSubcommand(std::unique_ptr<RefactoringAction> Action,
                               RefactoringActionRules ActionRules,
                               cl::OptionCategory &Category)
       : SubCommand(Action->getCommand(), Action->getDescription()),
         Action(std::move(Action)), ActionRules(std::move(ActionRules)) {
-    Sources = llvm::make_unique<cl::list<std::string>>(
-        cl::Positional, cl::ZeroOrMore, cl::desc("<source0> [... <sourceN>]"),
-        cl::cat(Category), cl::sub(*this));
-
     // Check if the selection option is supported.
     bool HasSelection = false;
     for (const auto &Rule : this->ActionRules) {
       if ((HasSelection = Rule->hasSelectionRequirement()))
         break;
     }
     if (HasSelection) {
       Selection = llvm::make_unique<cl::opt<std::string>>(
bool parseArguments() {
     }
     return false;
   }
 
   SourceSelectionArgument *getSelection() const {
     assert(Selection && "selection not supported!");
     return ParsedSelection.get();
   }
-
-  ArrayRef<std::string> getSources() const { return *Sources; }
-
 private:
   std::unique_ptr<RefactoringAction> Action;
   RefactoringActionRules ActionRules;
-  std::unique_ptr<cl::list<std::string>> Sources;
   std::unique_ptr<cl::opt<std::string>> Selection;
   std::unique_ptr<SourceSelectionArgument> ParsedSelection;
 };
 
 class ClangRefactorConsumer : public RefactoringResultConsumer {
 public:
   void handleError(llvm::Error Err) {
     llvm::errs() << llvm::toString(std::move(Err)) << "\n";
ClangRefactorTool() {
     }
   }
 
   using TUCallbackType = llvm::function_ref<void(ASTContext &)>;
 
   /// Parses the translation units that were given to the subcommand using
   /// the 'sources' option and invokes the callback for each parsed
   /// translation unit.
-  bool foreachTranslationUnit(RefactoringActionSubcommand &Subcommand,
+  bool foreachTranslationUnit(const CompilationDatabase &DB,
+                              ArrayRef<std::string> Sources,
                               TUCallbackType Callback) {
-    std::unique_ptr<CompilationDatabase> Compilations;
-    if (opts::NoDatabases) {
-      // FIXME (Alex L): Support compilation options.
-      Compilations =
-          llvm::make_unique<clang::tooling::FixedCompilationDatabase>(
-              ".", std::vector<std::string>());
-    } else {
-      // FIXME (Alex L): Support compilation database.
-      llvm::errs() << "compilation databases are not supported yet!\n";
-      return true;
-    }
-
     class ToolASTConsumer : public ASTConsumer {
     public:
       TUCallbackType Callback;
       ToolASTConsumer(TUCallbackType Callback) : Callback(Callback) {}
 
       void HandleTranslationUnit(ASTContext &Context) override {
         Callback(Context);
       }
     };
     class ActionWrapper {
     public:
       TUCallbackType Callback;
       ActionWrapper(TUCallbackType Callback) : Callback(Callback) {}
 
       std::unique_ptr<ASTConsumer> newASTConsumer() {
         return llvm::make_unique<ToolASTConsumer>(std::move(Callback));
       }
     };
 
-    ClangTool Tool(*Compilations, Subcommand.getSources());
+    ClangTool Tool(DB, Sources);
     ActionWrapper ToolAction(std::move(Callback));
     std::unique_ptr<tooling::FrontendActionFactory> Factory =
         tooling::newFrontendActionFactory(&ToolAction);
     return Tool.run(Factory.get());
   }
 
   /// Logs an individual refactoring action invocation to STDOUT.
   void logInvocation(RefactoringActionSubcommand &Subcommand,
                      const RefactoringRuleContext &Context) {
     if (!opts::Verbose)
       return;
     llvm::outs() << "invoking action '" << Subcommand.getName() << "':\n";
     if (Context.getSelectionRange().isValid()) {
       SourceRange R = Context.getSelectionRange();
       llvm::outs() << "  -selection=";
       R.getBegin().print(llvm::outs(), Context.getSources());
       llvm::outs() << " -> ";
       R.getEnd().print(llvm::outs(), Context.getSources());
       llvm::outs() << "\n";
     }
   }
 
-  bool invokeAction(RefactoringActionSubcommand &Subcommand) {
+  bool invokeAction(RefactoringActionSubcommand &Subcommand,
+                    const CompilationDatabase &DB,
+                    ArrayRef<std::string> Sources) {
     // Find a set of matching rules.
     SmallVector<RefactoringActionRule *, 4> MatchingRules;
     llvm::StringSet<> MissingOptions;
 
     bool HasSelection = false;
     for (const auto &Rule : Subcommand.getActionRules()) {
       if (Rule->hasSelectionRequirement()) {
         HasSelection = true;
if (MatchingRules.empty()) {
                    << "' can't be invoked with the given arguments:\n";
       for (const auto &Opt : MissingOptions)
         llvm::errs() << "  missing '-" << Opt.getKey() << "' option\n";
       return true;
     }
 
     bool HasFailed = false;
     ClangRefactorConsumer Consumer;
-    if (foreachTranslationUnit(Subcommand, [&](ASTContext &AST) {
+    if (foreachTranslationUnit(DB, Sources, [&](ASTContext &AST) {
           RefactoringRuleContext Context(AST.getSourceManager());
           Context.setASTContext(AST);
 
           auto InvokeRule = [&](RefactoringResultConsumer &Consumer) {
             logInvocation(Subcommand, Context);
             for (RefactoringActionRule *Rule : MatchingRules) {
               if (!Rule->hasSelectionRequirement())
                 continue;
public:
   }
 };
 
 } // end anonymous namespace
 
 int main(int argc, const char **argv) {
   ClangRefactorTool Tool;
 
-  // FIXME: Use LibTooling's CommonOptions parser when subcommands are supported
-  // by it.
-  cl::HideUnrelatedOptions(opts::CommonRefactorOptions);
-  cl::ParseCommandLineOptions(
-      argc, argv, "Clang-based refactoring tool for C, C++ and Objective-C");
-  cl::PrintOptionValues();
+  CommonOptionsParser Options(
+      argc, argv, opts::CommonRefactorOptions, cl::ZeroOrMore,
+      "Clang-based refactoring tool for C, C++ and Objective-C");
 
   // Figure out which action is specified by the user. The user must specify
   // the action using a command-line subcommand, e.g. the invocation
   // `clang-refactor local-rename` corresponds to the `LocalRename` refactoring
   // action. All subcommands must have a unique names. This allows us to figure
   // out which refactoring action should be invoked by looking at the first
   // subcommand that's enabled by LLVM's command-line parser.
   auto It = llvm::find_if(
       Tool.SubCommands,
       [](const std::unique_ptr<RefactoringActionSubcommand> &SubCommand) {
         return !!(*SubCommand);
       });
   if (It == Tool.SubCommands.end()) {
     llvm::errs() << "error: no refactoring action given\n";
     llvm::errs() << "note: the following actions are supported:\n";
     for (const auto &Subcommand : Tool.SubCommands)
       llvm::errs().indent(2) << Subcommand->getName() << "\n";
     return 1;
   }
   RefactoringActionSubcommand &ActionCommand = **It;
 
-  ArrayRef<std::string> Sources = ActionCommand.getSources();
-  // When -no-dbs is used, at least one file (TU) must be given to any
-  // subcommand.
-  if (opts::NoDatabases && Sources.empty()) {
-    llvm::errs() << "error: must provide paths to the source files when "
-                    "'-no-dbs' is used\n";
-    return 1;
-  }
   if (ActionCommand.parseArguments())
     return 1;
-  if (Tool.invokeAction(ActionCommand))
+  if (Tool.invokeAction(ActionCommand, Options.getCompilations(),
+                        Options.getSourcePathList()))
     return 1;
 
   return 0;
 }