Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===--- RefactoringActionRulesInternal.h - Clang refactoring library -----===//

//

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

//

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

#ifndef LLVM_CLANG_TOOLING_REFACTORING_REFACTORINGACTIONRULESINTERNAL_H

#define LLVM_CLANG_TOOLING_REFACTORING_REFACTORINGACTIONRULESINTERNAL_H

#include "clang/Basic/LLVM.h"

#include "clang/Tooling/Refactoring/RefactoringActionRule.h"

#include "clang/Tooling/Refactoring/RefactoringActionRuleRequirements.h"

#include "clang/Tooling/Refactoring/RefactoringResultConsumer.h"

#include "clang/Tooling/Refactoring/RefactoringRuleContext.h"

#include "llvm/Support/Error.h"

#include <type_traits>

namespace clang {

namespace tooling {

namespace internal {

inline llvm::Error findError() { return llvm::Error::success(); }

inline void ignoreError() {}

template <typename FirstT, typename... RestT>

void ignoreError(Expected<FirstT> &First, Expected<RestT> &... Rest) {

  if (!First)

    llvm::consumeError(First.takeError());

  ignoreError(Rest...);

}

/// Scans the tuple and returns a valid \c Error if any of the values are

/// invalid.

template <typename FirstT, typename... RestT>

llvm::Error findError(Expected<FirstT> &First, Expected<RestT> &... Rest) {

  if (!First) {

    ignoreError(Rest...);

    return First.takeError();

  }

  return findError(Rest...);

}

template <typename RuleType, typename... RequirementTypes, size_t... Is>

void invokeRuleAfterValidatingRequirements(

    RefactoringResultConsumer &Consumer, RefactoringRuleContext &Context,

    const std::tuple<RequirementTypes...> &Requirements,

    std::index_sequence<Is...>) {

  // Check if the requirements we're interested in can be evaluated.

  auto Values =

      std::make_tuple(std::get<Is>(Requirements).evaluate(Context)...);

  auto Err = findError(std::get<Is>(Values)...);

  if (Err)

    return Consumer.handleError(std::move(Err));

  // Construct the target action rule by extracting the evaluated

  // requirements from Expected<> wrappers and then run it.

  auto Rule =

      RuleType::initiate(Context, std::move((*std::get<Is>(Values)))...);

  if (!Rule)

    return Consumer.handleError(Rule.takeError());

  Rule->invoke(Consumer, Context);

}

inline void visitRefactoringOptionsImpl(RefactoringOptionVisitor &) {}

/// Scans the list of requirements in a rule and visits all the refactoring

/// options that are used by all the requirements.

template <typename FirstT, typename... RestT>

void visitRefactoringOptionsImpl(RefactoringOptionVisitor &Visitor,

                                 const FirstT &First, const RestT &... Rest) {

  struct OptionGatherer {

    RefactoringOptionVisitor &Visitor;

    void operator()(const RefactoringOptionsRequirement &Requirement) {

      for (const auto &Option : Requirement.getRefactoringOptions())

        Option->passToVisitor(Visitor);

    }

    void operator()(const RefactoringActionRuleRequirement &) {}

  };

  (OptionGatherer{Visitor})(First);

  return visitRefactoringOptionsImpl(Visitor, Rest...);

}

template <typename... RequirementTypes, size_t... Is>

void visitRefactoringOptions(

    RefactoringOptionVisitor &Visitor,

    const std::tuple<RequirementTypes...> &Requirements,

    std::index_sequence<Is...>) {

  visitRefactoringOptionsImpl(Visitor, std::get<Is>(Requirements)...);

}

/// A type trait that returns true when the given type list has at least one

/// type whose base is the given base type.

template <typename Base, typename First, typename... Rest>

struct HasBaseOf : std::conditional_t<HasBaseOf<Base, First>::value ||

                                          HasBaseOf<Base, Rest...>::value,

                                      std::true_type, std::false_type> {};

template <typename Base, typename T>

struct HasBaseOf<Base, T> : std::is_base_of<Base, T> {};

/// A type trait that returns true when the given type list contains types that

/// derive from Base.

template <typename Base, typename First, typename... Rest>

struct AreBaseOf : std::conditional_t<AreBaseOf<Base, First>::value &&

                                          AreBaseOf<Base, Rest...>::value,

                                      std::true_type, std::false_type> {};

template <typename Base, typename T>

struct AreBaseOf<Base, T> : std::is_base_of<Base, T> {};

} // end namespace internal

template <typename RuleType, typename... RequirementTypes>

std::unique_ptr<RefactoringActionRule>

createRefactoringActionRule(const RequirementTypes &... Requirements) {

  static_assert(std::is_base_of<RefactoringActionRuleBase, RuleType>::value,

                "Expected a refactoring action rule type");

  static_assert(internal::AreBaseOf<RefactoringActionRuleRequirement,

                                    RequirementTypes...>::value,

                "Expected a list of refactoring action rules");

  class Rule final : public RefactoringActionRule {

  public:

    Rule(std::tuple<RequirementTypes...> Requirements)

        : Requirements(Requirements) {}

    void invoke(RefactoringResultConsumer &Consumer,

                RefactoringRuleContext &Context) override {

      internal::invokeRuleAfterValidatingRequirements<RuleType>(

          Consumer, Context, Requirements,

          std::index_sequence_for<RequirementTypes...>());

    }

    bool hasSelectionRequirement() override {

      return internal::HasBaseOf<SourceSelectionRequirement,

                                 RequirementTypes...>::value;

    }

    void visitRefactoringOptions(RefactoringOptionVisitor &Visitor) override {

      internal::visitRefactoringOptions(

          Visitor, Requirements,

          std::index_sequence_for<RequirementTypes...>());

    }

  private:

    std::tuple<RequirementTypes...> Requirements;

  };

  return std::make_unique<Rule>(std::make_tuple(Requirements...));

}

} // end namespace tooling

} // end namespace clang

#endif // LLVM_CLANG_TOOLING_REFACTORING_REFACTORINGACTIONRULESINTERNAL_H