//===--- ClangRefactor.cpp - Clang-based refactoring tool -----------------===//

//

// 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

//

//===----------------------------------------------------------------------===//

///

/// \file

/// This file implements a clang-refactor tool that performs various

/// source transformations.

///

//===----------------------------------------------------------------------===//

#include "TestSupport.h"

#include "clang/Frontend/CommandLineSourceLoc.h"

#include "clang/Frontend/TextDiagnosticPrinter.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/RefactoringOptions.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/Signals.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("Refactoring options");

static cl::opt<bool> Verbose("v", cl::desc("Use verbose output"),

                             cl::cat(cl::getGeneralCategory()),

                             cl::sub(*cl::AllSubCommands));

static cl::opt<bool> Inplace("i", cl::desc("Inplace edit <file>s"),

                             cl::cat(cl::getGeneralCategory()),

                             cl::sub(*cl::AllSubCommands));

} // end namespace opts

namespace {

/// Stores the parsed `-selection` argument.

class SourceSelectionArgument {

public:

  virtual ~SourceSelectionArgument() {}

  /// Parse the `-selection` argument.

  ///

  /// \returns A valid argument when the parse succedeed, null otherwise.

  static std::unique_ptr<SourceSelectionArgument> fromString(StringRef Value);

  /// Prints any additional state associated with the selection argument to

  /// the given output stream.

  virtual void print(raw_ostream &OS) {}

  /// Returns a replacement refactoring result consumer (if any) that should

  /// consume the results of a refactoring operation.

  ///

  /// The replacement refactoring result consumer is used by \c

  /// TestSourceSelectionArgument to inject a test-specific result handling

  /// logic into the refactoring operation. The test-specific consumer

  /// ensures that the individual results in a particular test group are

  /// identical.

  virtual std::unique_ptr<ClangRefactorToolConsumerInterface>

  createCustomConsumer() {

    return nullptr;

  }

  /// Runs the give refactoring function for each specified selection.

  ///

  /// \returns true if an error occurred, false otherwise.

  virtual bool

  forAllRanges(const SourceManager &SM,

               llvm::function_ref<void(SourceRange R)> Callback) = 0;

};

/// Stores the parsed -selection=test:<filename> option.

class TestSourceSelectionArgument final : public SourceSelectionArgument {

public:

  TestSourceSelectionArgument(TestSelectionRangesInFile TestSelections)

      : TestSelections(std::move(TestSelections)) {}

  void print(raw_ostream &OS) override { TestSelections.dump(OS); }

  std::unique_ptr<ClangRefactorToolConsumerInterface>

  createCustomConsumer() override {

    return TestSelections.createConsumer();

  }

  /// Testing support: invokes the selection action for each selection range in

  /// the test file.

  bool forAllRanges(const SourceManager &SM,

                    llvm::function_ref<void(SourceRange R)> Callback) override {

    return TestSelections.foreachRange(SM, Callback);

  }

private:

  TestSelectionRangesInFile TestSelections;

};

/// Stores the parsed -selection=filename:line:column[-line:column] option.

class SourceRangeSelectionArgument final : public SourceSelectionArgument {

public:

  SourceRangeSelectionArgument(ParsedSourceRange Range)

      : Range(std::move(Range)) {}

  bool forAllRanges(const SourceManager &SM,

                    llvm::function_ref<void(SourceRange R)> Callback) override {

    auto FE = SM.getFileManager().getFile(Range.FileName);

    FileID FID = FE ? SM.translateFile(*FE) : 
FileID()0
;

    if (!FE || FID.isInvalid()) {

      llvm::errs() << "error: -selection=" << Range.FileName

                   << ":... : given file is not in the target TU\n";

      return true;

    }

    SourceLocation Start = SM.getMacroArgExpandedLocation(

        SM.translateLineCol(FID, Range.Begin.first, Range.Begin.second));

    SourceLocation End = SM.getMacroArgExpandedLocation(

        SM.translateLineCol(FID, Range.End.first, Range.End.second));

    if (Start.isInvalid() || End.isInvalid()) {

      llvm::errs() << "error: -selection=" << Range.FileName << ':'

                   << Range.Begin.first << ':' << Range.Begin.second << '-'

                   << Range.End.first << ':' << Range.End.second

                   << " : invalid source location\n";

      return true;

    }

    Callback(SourceRange(Start, End));

    return false;

  }

private:

  ParsedSourceRange Range;

};

std::unique_ptr<SourceSelectionArgument>

SourceSelectionArgument::fromString(StringRef Value) {

  if (Value.startswith("test:")) {

    StringRef Filename = Value.drop_front(strlen("test:"));

    Optional<TestSelectionRangesInFile> ParsedTestSelection =

        findTestSelectionRanges(Filename);

    if (!ParsedTestSelection)

      return nullptr; // A parsing error was already reported.

    return std::make_unique<TestSourceSelectionArgument>(

        std::move(*ParsedTestSelection));

  }

  Optional<ParsedSourceRange> Range = ParsedSourceRange::fromString(Value);

  if (Range)

    return std::make_unique<SourceRangeSelectionArgument>(std::move(*Range));

  llvm::errs() << "error: '-selection' option must be specified using "

                  "<file>:<line>:<column> or "

                  "<file>:<line>:<column>-<line>:<column> format\n";

  return nullptr;

}

/// A container that stores the command-line options used by a single

/// refactoring option.

class RefactoringActionCommandLineOptions {

public:

  void addStringOption(const RefactoringOption &Option,

                       std::unique_ptr<cl::opt<std::string>> CLOption) {

    StringOptions[&Option] = std::move(CLOption);

  }

  const cl::opt<std::string> &

  getStringOption(const RefactoringOption &Opt) const {

    auto It = StringOptions.find(&Opt);

    return *It->second;

  }

private:

  llvm::DenseMap<const RefactoringOption *,

                 std::unique_ptr<cl::opt<std::string>>>

      StringOptions;

};

/// Passes the command-line option values to the options used by a single

/// refactoring action rule.

class CommandLineRefactoringOptionVisitor final

    : public RefactoringOptionVisitor {

public:

  CommandLineRefactoringOptionVisitor(

      const RefactoringActionCommandLineOptions &Options)

      : Options(Options) {}

  void visit(const RefactoringOption &Opt,

             Optional<std::string> &Value) override {

    const cl::opt<std::string> &CLOpt = Options.getStringOption(Opt);

    if (!CLOpt.getValue().empty()) {

      Value = CLOpt.getValue();

      return;

    }

    Value = None;

    if (Opt.isRequired())

      MissingRequiredOptions.push_back(&Opt);

  }

  ArrayRef<const RefactoringOption *> getMissingRequiredOptions() const {

    return MissingRequiredOptions;

  }

private:

  llvm::SmallVector<const RefactoringOption *, 4> MissingRequiredOptions;

  const RefactoringActionCommandLineOptions &Options;

};

/// Creates the refactoring options used by all the rules in a single

/// refactoring action.

class CommandLineRefactoringOptionCreator final

    : public RefactoringOptionVisitor {

public:

  CommandLineRefactoringOptionCreator(

      cl::OptionCategory &Category, cl::SubCommand &Subcommand,

      RefactoringActionCommandLineOptions &Options)

      : Category(Category), Subcommand(Subcommand), Options(Options) {}

  void visit(const RefactoringOption &Opt, Optional<std::string> &) override {

    if (Visited.insert(&Opt).second)

      Options.addStringOption(Opt, create<std::string>(Opt));

  }

private:

  template <typename T>

  std::unique_ptr<cl::opt<T>> create(const RefactoringOption &Opt) {

    if (!OptionNames.insert(Opt.getName()).second)

      llvm::report_fatal_error("Multiple identical refactoring options "

                               "specified for one refactoring action");

    // FIXME: cl::Required can be specified when this option is present

    // in all rules in an action.

    return std::make_unique<cl::opt<T>>(

        Opt.getName(), cl::desc(Opt.getDescription()), cl::Optional,

        cl::cat(Category), cl::sub(Subcommand));

  }

  llvm::SmallPtrSet<const RefactoringOption *, 8> Visited;

  llvm::StringSet<> OptionNames;

  cl::OptionCategory &Category;

  cl::SubCommand &Subcommand;

  RefactoringActionCommandLineOptions &Options;

};

/// 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)) {

    // Check if the selection option is supported.

    for (const auto &Rule : this->ActionRules) {

      if (Rule->hasSelectionRequirement()) {

        Selection = std::make_unique<cl::opt<std::string>>(

            "selection",

            cl::desc(

                "The selected source range in which the refactoring should "

                "be initiated (<file>:<line>:<column>-<line>:<column> or "

                "<file>:<line>:<column>)"),

            cl::cat(Category), cl::sub(*this));

        break;

      }

    }

    // Create the refactoring options.

    for (const auto &Rule : this->ActionRules) {

      CommandLineRefactoringOptionCreator OptionCreator(Category, *this,

                                                        Options);

      Rule->visitRefactoringOptions(OptionCreator);

    }

  }

  ~RefactoringActionSubcommand() { unregisterSubCommand(); }

  const RefactoringActionRules &getActionRules() const { return ActionRules; }

  /// Parses the "-selection" command-line argument.

  ///

  /// \returns true on error, false otherwise.

  bool parseSelectionArgument() {

    if (Selection) {

      ParsedSelection = SourceSelectionArgument::fromString(*Selection);

      if (!ParsedSelection)

        return true;

    }

    return false;

  }

  SourceSelectionArgument *getSelection() const {

    assert(Selection && "selection not supported!");

    return ParsedSelection.get();

  }

  const RefactoringActionCommandLineOptions &getOptions() const {

    return Options;

  }

private:

  std::unique_ptr<RefactoringAction> Action;

  RefactoringActionRules ActionRules;

  std::unique_ptr<cl::opt<std::string>> Selection;

  std::unique_ptr<SourceSelectionArgument> ParsedSelection;

  RefactoringActionCommandLineOptions Options;

};

class ClangRefactorConsumer final : public ClangRefactorToolConsumerInterface {

public:

  ClangRefactorConsumer(AtomicChanges &Changes) : SourceChanges(&Changes) {}

  void handleError(llvm::Error Err) override {

    Optional<PartialDiagnosticAt> Diag = DiagnosticError::take(Err);

    if (!Diag) {

      llvm::errs() << llvm::toString(std::move(Err)) << "\n";

      return;

    }

    llvm::cantFail(std::move(Err)); // This is a success.

    DiagnosticBuilder DB(

        getDiags().Report(Diag->first, Diag->second.getDiagID()));

    Diag->second.Emit(DB);

  }

  void handle(AtomicChanges Changes) override {

    SourceChanges->insert(SourceChanges->begin(), Changes.begin(),

                          Changes.end());

  }

  void handle(SymbolOccurrences Occurrences) override {

    llvm_unreachable("symbol occurrence results are not handled yet");

  }

private:

  AtomicChanges *SourceChanges;

};

class ClangRefactorTool {

public:

  ClangRefactorTool()

      : SelectedSubcommand(nullptr), MatchingRule(nullptr),

        Consumer(new ClangRefactorConsumer(Changes)), HasFailed(false) {

    std::vector<std::unique_ptr<RefactoringAction>> Actions =

        createRefactoringActions();

    // Actions must have unique command names so that we can map them to one

    // subcommand.

    llvm::StringSet<> CommandNames;

    for (const auto &Action : Actions) {

      if (!CommandNames.insert(Action->getCommand()).second) {

        llvm::errs() << "duplicate refactoring action command '"

                     << Action->getCommand() << "'!";

        exit(1);

      }

    }

    // Create subcommands and command-line options.

    
for (auto &Action : Actions)19
 {

      SubCommands.push_back(std::make_unique<RefactoringActionSubcommand>(

          std::move(Action), Action->createActiveActionRules(),

          opts::CommonRefactorOptions));

    }

  }

  // Initializes the selected subcommand and refactoring rule based on the

  // command line options.

  llvm::Error Init() {

    auto Subcommand = getSelectedSubcommand();

    if (!Subcommand)

      return Subcommand.takeError();

    auto Rule = getMatchingRule(**Subcommand);

    if (!Rule)

      return Rule.takeError();

    SelectedSubcommand = *Subcommand;

    MatchingRule = *Rule;

    return llvm::Error::success();

  }

  bool hasFailed() const { return HasFailed; }

  using TUCallbackType = std::function<void(ASTContext &)>;

  // Callback of an AST action. This invokes the matching rule on the given AST.

  void callback(ASTContext &AST) {

    assert(SelectedSubcommand && MatchingRule && Consumer);

    RefactoringRuleContext Context(AST.getSourceManager());

    Context.setASTContext(AST);

    // If the selection option is test specific, we use a test-specific

    // consumer.

    std::unique_ptr<ClangRefactorToolConsumerInterface> TestConsumer;

    bool HasSelection = MatchingRule->hasSelectionRequirement();

    if (HasSelection)

      TestConsumer = SelectedSubcommand->getSelection()->createCustomConsumer();

    ClangRefactorToolConsumerInterface *ActiveConsumer =

        TestConsumer ? 
TestConsumer.get()10
 : 
Consumer.get()8
;

    ActiveConsumer->beginTU(AST);

    auto InvokeRule = [&](RefactoringResultConsumer &Consumer) {

      if (opts::Verbose)

        logInvocation(*SelectedSubcommand, Context);

      MatchingRule->invoke(*ActiveConsumer, Context);

    };

    if (HasSelection) {

      assert(SelectedSubcommand->getSelection() &&

             "Missing selection argument?");

      if (opts::Verbose)

        SelectedSubcommand->getSelection()->print(llvm::outs());

      if (SelectedSubcommand->getSelection()->forAllRanges(

              Context.getSources(), [&](SourceRange R) {

                Context.setSelectionRange(R);

                InvokeRule(*ActiveConsumer);

              }))

        HasFailed = true;

      ActiveConsumer->endTU();

      return;

    }

    InvokeRule(*ActiveConsumer);

    ActiveConsumer->endTU();

  }

  llvm::Expected<std::unique_ptr<FrontendActionFactory>>

  getFrontendActionFactory() {

    class ToolASTConsumer : public ASTConsumer {

    public:

      TUCallbackType Callback;

      ToolASTConsumer(TUCallbackType Callback)

          : Callback(std::move(Callback)) {}

      void HandleTranslationUnit(ASTContext &Context) override {

        Callback(Context);

      }

    };

    class ToolASTAction : public ASTFrontendAction {

    public:

      explicit ToolASTAction(TUCallbackType Callback)

          : Callback(std::move(Callback)) {}

    protected:

      std::unique_ptr<clang::ASTConsumer>

      CreateASTConsumer(clang::CompilerInstance &compiler,

                        StringRef /* dummy */) override {

        std::unique_ptr<clang::ASTConsumer> Consumer{

            new ToolASTConsumer(Callback)};

        return Consumer;

      }

    private:

      TUCallbackType Callback;

    };

    class ToolActionFactory : public FrontendActionFactory {

    public:

      ToolActionFactory(TUCallbackType Callback)

          : Callback(std::move(Callback)) {}

      std::unique_ptr<FrontendAction> create() override {

        return std::make_unique<ToolASTAction>(Callback);

      }

    private:

      TUCallbackType Callback;

    };

    return std::make_unique<ToolActionFactory>(

        [this](ASTContext &AST) { return callback(AST); });

  }

  // FIXME(ioeric): this seems to only works for changes in a single file at

  // this point.

  bool applySourceChanges() {

    std::set<std::string> Files;

    for (const auto &Change : Changes)

      Files.insert(Change.getFilePath());

    // FIXME: Add automatic formatting support as well.

    tooling::ApplyChangesSpec Spec;

    // FIXME: We should probably cleanup the result by default as well.

    Spec.Cleanup = false;

    for (const auto &File : Files) {

      llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> BufferErr =

          llvm::MemoryBuffer::getFile(File);

      if (!BufferErr) {

        llvm::errs() << "error: failed to open " << File << " for rewriting\n";

        return true;

      }

      auto Result = tooling::applyAtomicChanges(File, (*BufferErr)->getBuffer(),

                                                Changes, Spec);

      if (!Result) {

        llvm::errs() << toString(Result.takeError());

        return true;

      }

      if (opts::Inplace) {

        std::error_code EC;

        llvm::raw_fd_ostream OS(File, EC, llvm::sys::fs::OF_TextWithCRLF);

        if (EC) {

          llvm::errs() << EC.message() << "\n";

          return true;

        }

        OS << *Result;

        continue;

      }

      llvm::outs() << *Result;

    }

    return false;

  }

private:

  /// Logs an individual refactoring action invocation to STDOUT.

  void logInvocation(RefactoringActionSubcommand &Subcommand,

                     const RefactoringRuleContext &Context) {

    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";

    }

  }

  llvm::Expected<RefactoringActionRule *>

  getMatchingRule(RefactoringActionSubcommand &Subcommand) {

    SmallVector<RefactoringActionRule *, 4> MatchingRules;

    llvm::StringSet<> MissingOptions;

    for (const auto &Rule : Subcommand.getActionRules()) {

      CommandLineRefactoringOptionVisitor Visitor(Subcommand.getOptions());

      Rule->visitRefactoringOptions(Visitor);

      if (Visitor.getMissingRequiredOptions().empty()) {

        if (!Rule->hasSelectionRequirement()) {

          MatchingRules.push_back(Rule.get());

        } else {

          Subcommand.parseSelectionArgument();

          if (Subcommand.getSelection()) {

            MatchingRules.push_back(Rule.get());

          } else {

            MissingOptions.insert("selection");

          }

        }

      }

      for (const RefactoringOption *Opt : Visitor.getMissingRequiredOptions())

        MissingOptions.insert(Opt->getName());

    }

    if (MatchingRules.empty()) {

      std::string Error;

      llvm::raw_string_ostream OS(Error);

      OS << "ERROR: '" << Subcommand.getName()

         << "' can't be invoked with the given arguments:\n";

      for (const auto &Opt : MissingOptions)

        OS << "  missing '-" << Opt.getKey() << "' option\n";

      OS.flush();

      return llvm::make_error<llvm::StringError>(

          Error, llvm::inconvertibleErrorCode());

    }

    if (MatchingRules.size() != 1) {

      return llvm::make_error<llvm::StringError>(

          llvm::Twine("ERROR: more than one matching rule of action") +

              Subcommand.getName() + "was found with given options.",

          llvm::inconvertibleErrorCode());

    }

    return MatchingRules.front();

  }

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

  llvm::Expected<RefactoringActionSubcommand *> getSelectedSubcommand() {

    auto It = llvm::find_if(

        SubCommands,

        [](const std::unique_ptr<RefactoringActionSubcommand> &SubCommand) {

          return !!(*SubCommand);

        });

    if (It == SubCommands.end()) {

      std::string Error;

      llvm::raw_string_ostream OS(Error);

      OS << "error: no refactoring action given\n";

      OS << "note: the following actions are supported:\n";

      for (const auto &Subcommand : SubCommands)

        OS.indent(2) << Subcommand->getName() << "\n";

      OS.flush();

      return llvm::make_error<llvm::StringError>(

          Error, llvm::inconvertibleErrorCode());

    }

    RefactoringActionSubcommand *Subcommand = &(**It);

    return Subcommand;

  }

  std::vector<std::unique_ptr<RefactoringActionSubcommand>> SubCommands;

  RefactoringActionSubcommand *SelectedSubcommand;

  RefactoringActionRule *MatchingRule;

  std::unique_ptr<ClangRefactorToolConsumerInterface> Consumer;

  AtomicChanges Changes;

  bool HasFailed;

};

} // end anonymous namespace

int main(int argc, const char **argv) {

  llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);

  ClangRefactorTool RefactorTool;

  auto ExpectedParser = CommonOptionsParser::create(

      argc, argv, cl::getGeneralCategory(), cl::ZeroOrMore,

      "Clang-based refactoring tool for C, C++ and Objective-C");

  if (!ExpectedParser) {

    llvm::errs() << ExpectedParser.takeError();

    return 1;

  }

  CommonOptionsParser &Options = ExpectedParser.get();

  if (auto Err = RefactorTool.Init()) {

    llvm::errs() << llvm::toString(std::move(Err)) << "\n";

    return 1;

  }

  auto ActionFactory = RefactorTool.getFrontendActionFactory();

  if (!ActionFactory) {

    llvm::errs() << llvm::toString(ActionFactory.takeError()) << "\n";

    return 1;

  }

  ClangTool Tool(Options.getCompilations(), Options.getSourcePathList());

  bool Failed = false;

  if (Tool.run(ActionFactory->get()) != 0) {

    llvm::errs() << "Failed to run refactoring action on files\n";

    // It is possible that TUs are broken while changes are generated correctly,

    // so we still try applying changes.

    Failed = true;

  }

  return RefactorTool.applySourceChanges() || Failed ||

         
RefactorTool.hasFailed()17
;

}