1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 | //===--- RefactoringActions.cpp - Constructs refactoring actions ----------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "clang/Tooling/Refactoring/Extract/Extract.h" #include "clang/Tooling/Refactoring/RefactoringAction.h" #include "clang/Tooling/Refactoring/RefactoringOptions.h" #include "clang/Tooling/Refactoring/Rename/RenamingAction.h" namespace clang { namespace tooling { namespace { class DeclNameOption final : public OptionalRefactoringOption<std::string> { public: StringRef getName() const { return "name"; } StringRef getDescription() const { return "Name of the extracted declaration"; } }; // FIXME: Rewrite the Actions to avoid duplication of descriptions/names with // rules. class ExtractRefactoring final : public RefactoringAction { public: StringRef getCommand() const override { return "extract"; } StringRef getDescription() const override { return "(WIP action; use with caution!) Extracts code into a new function"; } /// Returns a set of refactoring actions rules that are defined by this /// action. RefactoringActionRules createActionRules() const override { RefactoringActionRules Rules; Rules.push_back(createRefactoringActionRule<ExtractFunction>( CodeRangeASTSelectionRequirement(), OptionRequirement<DeclNameOption>())); return Rules; } }; class OldQualifiedNameOption : public RequiredRefactoringOption<std::string> { public: StringRef getName() const override { return "old-qualified-name"; } StringRef getDescription() const override { return "The old qualified name to be renamed"; } }; class NewQualifiedNameOption : public RequiredRefactoringOption<std::string> { public: StringRef getName() const override { return "new-qualified-name"; } StringRef getDescription() const override { return "The new qualified name to change the symbol to"; } }; class NewNameOption : public RequiredRefactoringOption<std::string> { public: StringRef getName() const override { return "new-name"; } StringRef getDescription() const override { return "The new name to change the symbol to"; } }; // FIXME: Rewrite the Actions to avoid duplication of descriptions/names with // rules. class LocalRename final : public RefactoringAction { public: StringRef getCommand() const override { return "local-rename"; } StringRef getDescription() const override { return "Finds and renames symbols in code with no indexer support"; } /// Returns a set of refactoring actions rules that are defined by this /// action. RefactoringActionRules createActionRules() const override { RefactoringActionRules Rules; Rules.push_back(createRefactoringActionRule<RenameOccurrences>( SourceRangeSelectionRequirement(), OptionRequirement<NewNameOption>())); // FIXME: Use NewNameOption. Rules.push_back(createRefactoringActionRule<QualifiedRenameRule>( OptionRequirement<OldQualifiedNameOption>(), OptionRequirement<NewQualifiedNameOption>())); return Rules; } }; } // end anonymous namespace std::vector<std::unique_ptr<RefactoringAction>> createRefactoringActions() { std::vector<std::unique_ptr<RefactoringAction>> Actions; Actions.push_back(llvm::make_unique<LocalRename>()); Actions.push_back(llvm::make_unique<ExtractRefactoring>()); return Actions; } RefactoringActionRules RefactoringAction::createActiveActionRules() { // FIXME: Filter out rules that are not supported by a particular client. return createActionRules(); } } // end namespace tooling } // end namespace clang |