Add refactoring actions

Added redundand-if, redundand-while, unused-method,
unused-field, simplify-expr refactoring actions

Author: IgnatSergeev

clang/lib/Tooling/Refactoring/RefactoringActions.cpp

@@ -6,14 +6,22 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/ASTMatchers/ASTMatchersMacros.h"
+#include "clang/Tooling/Refactoring/Edit/EditMatchRule.h"
 #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"
+#include "clang/Tooling/Transformer/RewriteRule.h"
+#include "clang/Tooling/Transformer/Stencil.h"
 
 namespace clang {
 namespace tooling {
 
+using namespace transformer;
+using namespace ast_matchers;
+
 namespace {
 
 class DeclNameOption final : public OptionalRefactoringOption<std::string> {
@@ -93,13 +101,150 @@ class LocalRename final : public RefactoringAction {
   }
 };
 
+class RedundandIf final : public RefactoringAction {
+public:
+  StringRef getCommand() const override { return "redundand-if"; }
+
+  StringRef getDescription() const override {
+    return "Transforms if statement around given location with always true or "
+           "false condition";
+  }
+
+  /// Returns a set of refactoring actions rules that are defined by this
+  /// action.
+  RefactoringActionRules createActionRules() const override {
+    RefactoringActionRules Rules;
+    Rules.push_back(createRefactoringActionRule<EditMatchRule>(
+        ASTLocMatchRequirement<StatementMatcher>(ifStmt(
+            allOf(anyOf(hasCondition(cxxBoolLiteral(equals(true)).bind("true")),
+                        hasCondition(cxxBoolLiteral(equals(false)))),
+                  optionally(hasThen(stmt().bind("then"))),
+                  optionally(hasElse(stmt().bind("else")))))),
+        EditGeneratorRequirement(ifBound(
+            "true", ifBound("then", changeTo(cat(node("then")))),
+            ifBound("else", changeTo(cat(node("else"))), changeTo(cat("")))))));
+
+    return Rules;
+  }
+};
+
+class RedundandWhile final : public RefactoringAction {
+public:
+  StringRef getCommand() const override { return "redundand-while"; }
+
+  StringRef getDescription() const override {
+    return "Removes while statement around given location with always false "
+           "condition";
+  }
+
+  /// Returns a set of refactoring actions rules that are defined by this
+  /// action.
+  RefactoringActionRules createActionRules() const override {
+    RefactoringActionRules Rules;
+    Rules.push_back(createRefactoringActionRule<EditMatchRule>(
+        ASTLocMatchRequirement<StatementMatcher>(
+            whileStmt(hasCondition(cxxBoolLiteral(equals(false))))),
+        EditGeneratorRequirement(edit(changeTo(cat(""))))));
+
+    return Rules;
+  }
+};
+
+AST_MATCHER(Decl, isReferenced) { return Node.isReferenced(); }
+
+class UnusedField final : public RefactoringAction {
+public:
+  StringRef getCommand() const override { return "unused-field"; }
+
+  StringRef getDescription() const override {
+    return "Removes unused field of a class around given location";
+  }
+
+  /// Returns a set of refactoring actions rules that are defined by this
+  /// action.
+  RefactoringActionRules createActionRules() const override {
+    RefactoringActionRules Rules;
+    Rules.push_back(createRefactoringActionRule<EditMatchRule>(
+        ASTLocMatchRequirement<DeclarationMatcher>(
+            fieldDecl(unless(isReferenced()),
+                      unless(hasAttr(attr::Kind::Unused)))
+                .bind("field")),
+        EditGeneratorRequirement(edit(changeTo(node("field"), cat(""))))));
+
+    return Rules;
+  }
+};
+
+class UnusedMethod final : public RefactoringAction {
+public:
+  StringRef getCommand() const override { return "unused-method"; }
+
+  StringRef getDescription() const override {
+    return "Removes unused method of a class around given location";
+  }
+
+  /// Returns a set of refactoring actions rules that are defined by this
+  /// action.
+  RefactoringActionRules createActionRules() const override {
+    RefactoringActionRules Rules;
+    Rules.push_back(createRefactoringActionRule<EditMatchRule>(
+        ASTLocMatchRequirement<DeclarationMatcher>(
+            cxxMethodDecl(unless(isReferenced()),
+                          unless(hasAttr(attr::Kind::Unused)))
+                .bind("method")),
+        EditGeneratorRequirement(edit(changeTo(node("method"), cat(""))))));
+
+    return Rules;
+  }
+};
+
+class SimplifyExpr final : public RefactoringAction {
+public:
+  StringRef getCommand() const override { return "simplify-expr"; }
+
+  StringRef getDescription() const override {
+    return "Simplifies expr around given location";
+  }
+
+  /// Returns a set of refactoring actions rules that are defined by this
+  /// action.
+  RefactoringActionRules createActionRules() const override {
+    RefactoringActionRules Rules;
+    Rules.push_back(createRefactoringActionRule<EditMatchRule>(
+        ASTLocMatchRequirement<StatementMatcher>(anyOf(
+            binaryOperator(
+                hasOperatorName("&&"), hasRHS(expr().bind("rhs")),
+                hasLHS(expr().bind("lhs")),
+                anyOf(hasRHS(cxxBoolLiteral(equals(false)).bind("save-rhs")),
+                      hasLHS(cxxBoolLiteral(equals(false))),
+                      hasRHS(cxxBoolLiteral(equals(true))),
+                      hasLHS(cxxBoolLiteral(equals(true)).bind("save-rhs")))),
+            binaryOperator(
+                hasOperatorName("||"), hasRHS(expr().bind("rhs")),
+                hasLHS(expr().bind("lhs")),
+                anyOf(hasRHS(cxxBoolLiteral(equals(false))),
+                      hasLHS(cxxBoolLiteral(equals(false)).bind("save-rhs")),
+                      hasRHS(cxxBoolLiteral(equals(true)).bind("save-rhs")),
+                      hasLHS(cxxBoolLiteral(equals(true))))))),
+        EditGeneratorRequirement(ifBound("save-rhs", changeTo(cat(node("rhs"))),
+                                         changeTo(cat(node("lhs")))))));
+
+    return Rules;
+  }
+};
+
 } // end anonymous namespace
 
 std::vector<std::unique_ptr<RefactoringAction>> createRefactoringActions() {
   std::vector<std::unique_ptr<RefactoringAction>> Actions;
 
   Actions.push_back(std::make_unique<LocalRename>());
   Actions.push_back(std::make_unique<ExtractRefactoring>());
+  Actions.push_back(std::make_unique<RedundandIf>());
+  Actions.push_back(std::make_unique<RedundandWhile>());
+  Actions.push_back(std::make_unique<UnusedField>());
+  Actions.push_back(std::make_unique<UnusedMethod>());
+  Actions.push_back(std::make_unique<SimplifyExpr>());
 
   return Actions;
 }