//===- lib/Tooling/Execution.cpp - Standalone clang action execution. -----===//

//

// 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 "clang/Tooling/StandaloneExecution.h"

#include "clang/Tooling/ToolExecutorPluginRegistry.h"

namespace clang {

namespace tooling {

static llvm::Error make_string_error(const llvm::Twine &Message) {

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

                                             llvm::inconvertibleErrorCode());

}

const char *StandaloneToolExecutor::ExecutorName = "StandaloneToolExecutor";

static ArgumentsAdjuster getDefaultArgumentsAdjusters() {

  return combineAdjusters(

      getClangStripOutputAdjuster(),

      combineAdjusters(getClangSyntaxOnlyAdjuster(),

                       getClangStripDependencyFileAdjuster()));

}

StandaloneToolExecutor::StandaloneToolExecutor(

    const CompilationDatabase &Compilations,

    llvm::ArrayRef<std::string> SourcePaths,

    IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS,

    std::shared_ptr<PCHContainerOperations> PCHContainerOps)

    : Tool(Compilations, SourcePaths, std::move(PCHContainerOps),

           std::move(BaseFS)),

      Context(&Results), ArgsAdjuster(getDefaultArgumentsAdjusters()) {

  // Use self-defined default argument adjusters instead of the default

  // adjusters that come with the old `ClangTool`.

  Tool.clearArgumentsAdjusters();

}

StandaloneToolExecutor::StandaloneToolExecutor(

    CommonOptionsParser Options,

    std::shared_ptr<PCHContainerOperations> PCHContainerOps)

    : OptionsParser(std::move(Options)),

      Tool(OptionsParser->getCompilations(), OptionsParser->getSourcePathList(),

           std::move(PCHContainerOps)),

      Context(&Results), ArgsAdjuster(getDefaultArgumentsAdjusters()) {

  Tool.clearArgumentsAdjusters();

}

llvm::Error StandaloneToolExecutor::execute(

    llvm::ArrayRef<

        std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>

        Actions) {

  if (Actions.empty())

    return make_string_error("No action to execute.");

  if (Actions.size() != 1)

    return make_string_error(

        "Only support executing exactly 1 action at this point.");

  auto &Action = Actions.front();

  Tool.appendArgumentsAdjuster(Action.second);

  Tool.appendArgumentsAdjuster(ArgsAdjuster);

  if (Tool.run(Action.first.get()))

    return make_string_error("Failed to run action.");

  return llvm::Error::success();

}

class StandaloneToolExecutorPlugin : public ToolExecutorPlugin {

public:

  llvm::Expected<std::unique_ptr<ToolExecutor>>

  create(CommonOptionsParser &OptionsParser) override {

    if (OptionsParser.getSourcePathList().empty())

      return make_string_error(

          "[StandaloneToolExecutorPlugin] No positional argument found.");

    return std::make_unique<StandaloneToolExecutor>(std::move(OptionsParser));

  }

};

static ToolExecutorPluginRegistry::Add<StandaloneToolExecutorPlugin>

    X("standalone", "Runs FrontendActions on a set of files provided "

                    "via positional arguments.");

// This anchor is used to force the linker to link in the generated object file

// and thus register the plugin.

volatile int StandaloneToolExecutorAnchorSource = 0;

} // end namespace tooling

} // end namespace clang