[refactor] add a refactoring action rule that returns symbol occurrences

[arphaman]

Summary

This patch adds a second kind of refactoring action rule that produces symbol occurrences. It will be used by the updated clang-refactor patch at https://reviews.llvm.org/D36574.

[ioeric]

Lgtm

[hokein]

include/clang/Tooling/Refactoring/RefactoringActionRule.h

29

I might miss some context here. As per your comment in https://reviews.llvm.org/D36075#inline-323769, you'll try to remove this tag, so I think we will hold off this patch until that is done?

unittests/Tooling/RefactoringActionRulesTest.cpp

167

I'm not a fan of passing a const smart_pointer& as function parameter. The function being called doesn't care about the lifetime management, so I'd use a raw pointer here.

[arphaman]

include/clang/Tooling/Refactoring/RefactoringActionRule.h

29

Yeah, that would be better. I will remove the tag first.

[arphaman]

Rebase on top of https://reviews.llvm.org/D37291

[JonasToth]

sry. misconfigured herald :(

[arphaman]

Rebase on ToT

[arphaman]

Committed in r313025

include/clang/Tooling/Refactoring/RefactoringActionRule.h

 //===--- RefactoringActionRule.h - Clang refactoring library -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLING_REFACTOR_REFACTORING_ACTION_RULE_H
 #define LLVM_CLANG_TOOLING_REFACTOR_REFACTORING_ACTION_RULE_H
 
 #include "clang/Basic/LLVM.h"
 #include "clang/Tooling/Refactoring/AtomicChange.h"
+#include "clang/Tooling/Refactoring/Rename/SymbolOccurrences.h"
 #include "llvm/Support/Error.h"
 #include <vector>
 
 namespace clang {
 namespace tooling {
 
 class RefactoringRuleContext;
 
 /// A common refactoring action rule interface.
 class RefactoringActionRule {
 public:
-  enum RuleKind { SourceChangeRefactoringRuleKind };
+  enum RuleKind {
+    SourceChangeRefactoringRuleKind,
+    FindSymbolOccurrencesRefactoringRuleKind
+  };
 
   RuleKind getRuleKind() const { return Kind; }
 
   virtual ~RefactoringActionRule() {}
 
 protected:
   RefactoringActionRule(RuleKind Kind) : Kind(Kind) {}
 
public:
   virtual Expected<Optional<AtomicChanges>>
   createSourceReplacements(RefactoringRuleContext &Context) = 0;
 
   static bool classof(const RefactoringActionRule *Rule) {
     return Rule->getRuleKind() == SourceChangeRefactoringRuleKind;
   }
 };
 
+/// An interactive refactoring action that produces symbol occurrences. The
+/// consumer is able to let the user decide which occurrences should be used
+/// and how the replacements shall be constructed when performing actions
+/// like rename.
+class FindSymbolOccurrencesRefactoringRule : public RefactoringActionRule {
+public:
+  FindSymbolOccurrencesRefactoringRule()
+      : RefactoringActionRule(FindSymbolOccurrencesRefactoringRuleKind) {}
+
+  /// Initiates and performs an interactive refactoring action that searches
+  /// for symbol occurrences.
+  ///
+  /// The specific rule must return an llvm::Error with a DiagnosticError
+  /// payload or None when the refactoring action couldn't be initiated/
+  /// performed, or \c SymbolOccurrences when the action was performed
+  /// successfully.
+  virtual Expected<Optional<SymbolOccurrences>>
+  findSymbolOccurrences(RefactoringRuleContext &Context) = 0;
+
+  static bool classof(const RefactoringActionRule *Rule) {
+    return Rule->getRuleKind() == FindSymbolOccurrencesRefactoringRuleKind;
+  }
+};
+
 /// A set of refactoring action rules that should have unique initiation
 /// requirements.
 using RefactoringActionRules =
     std::vector<std::unique_ptr<RefactoringActionRule>>;
 
 } // end namespace tooling
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLING_REFACTOR_REFACTORING_ACTION_RULE_H

include/clang/Tooling/Refactoring/RefactoringActionRulesInternal.h

 namespace tooling {
 namespace refactoring_action_rules {
 namespace internal {
 
 /// A wrapper around a specific refactoring action rule that calls a generic
 /// 'perform' method from the specific refactoring method.
 template <typename T> struct SpecificRefactoringRuleAdapter {};
 
-template <>
-class SpecificRefactoringRuleAdapter<AtomicChanges>
-    : public SourceChangeRefactoringRule {
-public:
-  virtual Expected<Optional<AtomicChanges>>
-  perform(RefactoringRuleContext &Context) = 0;
-
-  Expected<Optional<AtomicChanges>>
-  createSourceReplacements(RefactoringRuleContext &Context) final override {
-    return perform(Context);
-  }
+#define CLANG_REFACTOR_DEFINE_RULE_ADAPTER(ResultType, RuleType, OverrideName) \
+  template <>                                                                  \
+  class SpecificRefactoringRuleAdapter<ResultType> : public RuleType {         \
+  public:                                                                      \
+    virtual Expected<Optional<ResultType>>                                     \
+    perform(RefactoringRuleContext &Context) = 0;                              \
+                                                                               \
+    Expected<Optional<ResultType>>                                             \
+    OverrideName(RefactoringRuleContext &Context) final override {             \
+      return perform(Context);                                                 \
+    }                                                                          \
   };
 
+CLANG_REFACTOR_DEFINE_RULE_ADAPTER(AtomicChanges, SourceChangeRefactoringRule,
+                                   createSourceReplacements)
+CLANG_REFACTOR_DEFINE_RULE_ADAPTER(SymbolOccurrences,
+                                   FindSymbolOccurrencesRefactoringRule,
+                                   findSymbolOccurrences)
+
+#undef CLANG_REFACTOR_DEFINE_RULE_ADAPTER
+
 /// A specialized refactoring action rule that calls the stored function once
 /// all the of the requirements are fullfilled. The values produced during the
 /// evaluation of requirements are passed to the stored function.
 template <typename ResultType, typename FunctionType,
           typename... RequirementTypes>
 class PlainFunctionRule final
     : public SpecificRefactoringRuleAdapter<ResultType> {
 public:

unittests/Tooling/RefactoringActionRulesTest.cpp

 //===- unittest/Tooling/RefactoringTestActionRulesTest.cpp ----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ReplacementTest.h"
 #include "RewriterTestContext.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Refactoring/RefactoringActionRules.h"
+#include "clang/Tooling/Refactoring/Rename/SymbolName.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Errc.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace tooling;
 using namespace refactoring_action_rules;
 
TEST_F(RefactoringActionRulesTest, ReturnInitiationDiagnostic) {
   ASSERT_TRUE(!Result);
   std::string Message;
   llvm::handleAllErrors(Result.takeError(), [&](llvm::StringError &Error) {
     Message = Error.getMessage();
   });
   EXPECT_EQ(Message, "bad selection");
 }
 
+Expected<Optional<SymbolOccurrences>>
+findOccurrences(const std::unique_ptr<RefactoringActionRule> &Rule,
+                RefactoringRuleContext &Context) {
+  return cast<FindSymbolOccurrencesRefactoringRule>(*Rule)
+      .findSymbolOccurrences(Context);
+}
+
+TEST_F(RefactoringActionRulesTest, ReturnSymbolOccurrences) {
+  auto Rule = createRefactoringRule(
+      [](selection::SourceSelectionRange Selection)
+          -> Expected<SymbolOccurrences> {
+        SymbolOccurrences Occurrences;
+        Occurrences.push_back(SymbolOccurrence(
+            SymbolName("test"), SymbolOccurrence::MatchingSymbol,
+            Selection.getRange().getBegin()));
+        return Occurrences;
+      },
+      requiredSelection(
+          selection::identity<selection::SourceSelectionRange>()));
+
+  RefactoringRuleContext RefContext(Context.Sources);
+  SourceLocation Cursor =
+      Context.Sources.getLocForStartOfFile(Context.Sources.getMainFileID());
+  RefContext.setSelectionRange({Cursor, Cursor});
+  Expected<Optional<SymbolOccurrences>> Result =
+      findOccurrences(Rule, RefContext);
+
+  ASSERT_FALSE(!Result);
+  ASSERT_FALSE(!*Result);
+  SymbolOccurrences Occurrences = std::move(**Result);
+  EXPECT_EQ(Occurrences.size(), 1u);
+  EXPECT_EQ(Occurrences[0].getKind(), SymbolOccurrence::MatchingSymbol);
+  EXPECT_EQ(Occurrences[0].getNameRanges().size(), 1u);
+  EXPECT_EQ(Occurrences[0].getNameRanges()[0],
+            SourceRange(Cursor, Cursor.getLocWithOffset(strlen("test"))));
+}
+
 } // end anonymous namespace