[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 ↗

(On Diff #112881)

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

180

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 ↗

(On Diff #112881)

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/RefactoringResultConsumer.h

 //===--- RefactoringResultConsumer.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_RESULT_CONSUMER_H
 #define LLVM_CLANG_TOOLING_REFACTOR_REFACTORING_RESULT_CONSUMER_H
 
 #include "clang/Basic/LLVM.h"
 #include "clang/Tooling/Refactoring/AtomicChange.h"
+#include "clang/Tooling/Refactoring/Rename/SymbolOccurrences.h"
 #include "llvm/Support/Error.h"
 
 namespace clang {
 namespace tooling {
 
 /// An abstract interface that consumes the various refactoring results that can
 /// be produced by refactoring actions.
 ///
 /// A valid refactoring result must be handled by a \c handle method.
 class RefactoringResultConsumer {
 public:
   virtual ~RefactoringResultConsumer() {}
 
   /// Handles an initation or an invication error. An initiation error typically
   /// has a \c DiagnosticError payload that describes why initation failed.
   virtual void handleError(llvm::Error Err) = 0;
 
   /// Handles the source replacements that are produced by a refactoring action.
   virtual void handle(AtomicChanges SourceReplacements) {
     defaultResultHandler();
   }
 
+  /// Handles the symbol occurrences that are found by an interactive
+  /// refactoring action.
+  virtual void handle(SymbolOccurrences Occurrences) { defaultResultHandler(); }
+
 private:
   void defaultResultHandler() {
     handleError(llvm::make_error<llvm::StringError>(
         "unsupported refactoring result", llvm::inconvertibleErrorCode()));
   }
 };
 
 namespace traits {

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");
 }
 
+Optional<SymbolOccurrences> findOccurrences(RefactoringActionRule &Rule,
+                                            RefactoringRuleContext &Context) {
+  class Consumer final : public RefactoringResultConsumer {
+    void handleError(llvm::Error) override {}
+    void handle(SymbolOccurrences Occurrences) override {
+      Result = std::move(Occurrences);
+    }
+
+  public:
+    Optional<SymbolOccurrences> Result;
+  };
+
+  Consumer C;
+  Rule.invoke(C, Context);
+  return std::move(C.Result);
+}
+
+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});
+  Optional<SymbolOccurrences> Result = findOccurrences(*Rule, RefContext);
+
+  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