[clang-refactor] introducing clang-refactor

[omtcyfz]

Summary

Adding clang-refactor with a dummy template refactoring module.

The tool itself doesn't have to be perfect in the first iteration, so I would be really happy to push this one early enough so that everyone could start building modules on top of it. As soon as this one is landed more refactoring and cleanup patches are welcome. This also isn't about "the one true way how clang-refactor has to be designed". Thus said, consider this version of clang-refactor to be highly experimental.

Clang-refactor design doc can be found here: https://docs.google.com/document/d/1w9IkR0_Gqmd5w4CZ2t_ZDZrNLYVirQPyMS41533HQZE/edit?usp=sharing

UPD: This diff was stalled for a while, clang-refactor was introduced in https://reviews.llvm.org/D36574 patch by araphman. Removing everyone from subscribers and reviewers for convenience.

[ioeric]

• You mentioned a design doc in the summary; maybe also include a link to it?
• It would make the review easier if you could separate the migration of clang-rename into another patch...I think clang-refactor is really the interesting part here. And maybe also add a small dummy sub-module as an example demonstrating how to add a new sub-module, which I believe will be helpful for future developers. (See also tool-template which exists for the same purpose.)

TemplatedClassFunction.cpp

1

What is this file for?

[omtcyfz]

In D24192#532981, @ioeric wrote:

• You mentioned a design doc in the summary; maybe also include a link to it?

Done.

• It would make the review easier if you could separate the migration of clang-rename into another patch...I think clang-refactor is really the interesting part here. And maybe also add a small dummy sub-module as an example demonstrating how to add a new sub-module, which I believe will be helpful for future developers. (See also tool-template which exists for the same purpose.)

I am not against it, but I do not think that an empty tool, which just introduces the binary without any code would be reasonable. This is basically why I wanted it to be all-in-place.

The whole changelist doesn't introduce anything really new, so I assume it might be fine. But if you are not okay with it I can split.

TemplatedClassFunction.cpp

1

This is a test. It is the reason clang-refactor rename fails :)

[omtcyfz]

Removed "clang-refactor (as opposed to clang-rename) now uses LLVM policy about brackets around single line statements in if/while/..." change to make the review a bit easier.

[omtcyfz]

Revert diff, as the last one "deletes and creates" files instead of "moving and changing them" in the filesystem.

[omtcyfz]

In D24192#532981, @ioeric wrote:

• It would make the review easier if you could separate the migration of clang-rename into another patch...

Another point is that if I try to separate the migration - what do I do about USREngine? USREngine is basically the core of clang-refactor at the moment and I can't detach it from clang-rename at the same time.

[ioeric]

In D24192#533174, @omtcyfz wrote:

In D24192#532981, @ioeric wrote:

• It would make the review easier if you could separate the migration of clang-rename into another patch...

Another point is that if I try to separate the migration - what do I do about USREngine? USREngine is basically the core of clang-refactor at the moment and I can't detach it from clang-rename at the same time.

I'm not sure why USREngine is the core of clang-refactor. It seems to me that USREngine is more closely tied to clang-rename than to clang-refactor. At least USREngine is not essential to all refactor tools, and it is more like a library that sub-modules can use.

[omtcyfz]

In D24192#533198, @ioeric wrote:

In D24192#533174, @omtcyfz wrote:

In D24192#532981, @ioeric wrote:

• It would make the review easier if you could separate the migration of clang-rename into another patch...

Another point is that if I try to separate the migration - what do I do about USREngine? USREngine is basically the core of clang-refactor at the moment and I can't detach it from clang-rename at the same time.

I'm not sure why USREngine is the core of clang-refactor. It seems to me that USREngine is more closely tied to clang-rename than to clang-refactor. At least USREngine is not essential to all refactor tools, and it is more like a library that sub-modules can use.

It is essential to all of the tools I wrote about in design doc.

Well, are you proposing to create an "empty" clang-refactor binary in one patch and adding meaningful code in the other? I am not sure if just creating clang-refactor/driver/Driver.cpp with main, which doesn't do anything is a good idea, but if you think it is - I'll do that.

[ioeric]

In D24192#533082, @omtcyfz wrote:

In D24192#532981, @ioeric wrote:

• You mentioned a design doc in the summary; maybe also include a link to it?

Done.

• It would make the review easier if you could separate the migration of clang-rename into another patch...I think clang-refactor is really the interesting part here. And maybe also add a small dummy sub-module as an example demonstrating how to add a new sub-module, which I believe will be helpful for future developers. (See also tool-template which exists for the same purpose.)

I am not against it, but I do not think that an empty tool, which just introduces the binary without any code would be reasonable. This is basically why I wanted it to be all-in-place.

The whole changelist doesn't introduce anything really new, so I assume it might be fine. But if you are not okay with it I can split.

Don't worry about a patch being small. Reviewers like small patches :)

The reason that I suggested a dummy sub-tool is to lower the bar for developers, especially those who have never developed a clang tool, so that they can easily figure out how to set up a clang-refactor sub-tool.

For a "swiss-army knife" tool like clang-refactor, I would worry more about the extendibility of the infrastructure instead of functionality at this stage. At least, I would expect it to be much easier to create a refactor tool under clang-refactor than creating a standalone clang tool. For example, it would be really nice if there is a tool base that a sub-module can derive from so that I don't have to go through the whole process of creating a clang tool and setting up unit/lit test environment :)

[ioeric]

In D24192#533200, @omtcyfz wrote:

In D24192#533198, @ioeric wrote:

In D24192#533174, @omtcyfz wrote:

In D24192#532981, @ioeric wrote:

• It would make the review easier if you could separate the migration of clang-rename into another patch...

Another point is that if I try to separate the migration - what do I do about USREngine? USREngine is basically the core of clang-refactor at the moment and I can't detach it from clang-rename at the same time.

I'm not sure why USREngine is the core of clang-refactor. It seems to me that USREngine is more closely tied to clang-rename than to clang-refactor. At least USREngine is not essential to all refactor tools, and it is more like a library that sub-modules can use.

It is essential to all of the tools I wrote about in design doc.

Well, are you proposing to create an "empty" clang-refactor binary in one patch and adding meaningful code in the other? I am not sure if just creating clang-refactor/driver/Driver.cpp with main, which doesn't do anything is a good idea, but if you think it is - I'll do that.

It was not trivial to me why USREngine is so important to those tools. You might want to address that in the design doc as well. And given the weight USREngine carries in clang-refactor as you suggested, I think it deserves an more detailed introduction in the design doc.

[alexander-shaposhnikov]

clang-refactor/driver/Rename.h

193

if i am not mistaken if the file has not been modified this will print smth like
"invalid source location" or similar. Pls, double check me.

[omtcyfz]

In D24192#533233, @ioeric wrote:

It was not trivial to me why USREngine is so important to those tools. You might want to address that in the design doc as well. And given the weight USREngine carries in clang-refactor as you suggested, I think it deserves an more detailed introduction in the design doc.

Yes, I agree, it might be a little confusing. The only mention I have is:

The most important facility would allow lookup of symbol definitions and usages (probably, based on Unified Symbol Resolutions, USR)

But it doesn't get into too much details anyway. However, the idea of the design doc was not to focus on implementation details too much as they are a subject to change.

Thus, I'm not sure whether I should elaborate details of USREngine there.

clang-refactor/driver/Rename.h

193

Sorry, can you please elaborate?

Also, this might be unrelated to this exact patch, but if there is an issue it's good to fix it in another patch. Basically, this is not new code, it's been there in clang-rename.

[omtcyfz]

In D24192#533220, @ioeric wrote:

Don't worry about a patch being small. Reviewers like small patches :)

The reason that I suggested a dummy sub-tool is to lower the bar for developers, especially those who have never developed a clang tool, so that they can easily figure out how to set up a clang-refactor sub-tool.

For a "swiss-army knife" tool like clang-refactor, I would worry more about the extendibility of the infrastructure instead of functionality at this stage. At least, I would expect it to be much easier to create a refactor tool under clang-refactor than creating a standalone clang tool. For example, it would be really nice if there is a tool base that a sub-module can derive from so that I don't have to go through the whole process of creating a clang tool and setting up unit/lit test environment :)

Yes, you are absolutely right. This patch is just a mess, because I tried to push everything at once while most of the stuff is not related to clang-refactor part at all.

I pushed 3 very basic cleanup patches (namely rL280638, rL280639 and rL280640), which don't really need reviewing (and also for the sake of development speed). And I also kept clang-rename improvements separate in D24224, which is up for review.

I'll update this patch tomorrow.

What I'm about to do after is to either:

1. Make two patches, one of which would basically create "empty" clang-refactor and introduce dummy submodule to show how it works (as you proposed), and the other would merge clang-rename as a submodule.
2. Make one patch, which both creates clang-refactor binary and merges clang-rename as a submodule.

The first variant seems better to me while I see a couple of issues with that, which makes sticking to the second variant a bit less challenging. We can discuss it tomorr..today and come up with a solution.

Thank you very much for your comments, Eric!

[omtcyfz]

Removed whole clang-rename part, only making this patch clang-refactor specific.

[omtcyfz]

Bringing results of an offline discussion with Eric (@ioeric) live.

Eric's point was that this patch should only care about clang-refactor and introduce changes directly related to creating clang-rename. clang-rename and all other tools migration can be done later, which is also good in terms of this patch not growing too large.

Another point was that it should be easier if there would be a class, from which refactoring tools would derive and use it as an interface.

Advantages are as follows:

• It would be easier to implement multi-TU support as the tools wouldn't simply care about that part while delegating the "hard work" to the common part.
• It would be easier to implement new tools, because there will be a slightly simpler interface.
• It would be easier to setup unit tests and other routine, because right now all tools have to implement basic routine for unit tests, for example, which is just copied from the other tools' unit tests with slight changes. Delegating that to the common interface is also nice.

The current diff isn't final, but I wanted to bring it to the reviews, because it gives an overview of what I am doing and if there are any high-level comments to address it's better to get them sooner than later.

[hokein]

Eric's point was that this patch should only care about clang-refactor and introduce changes directly related to creating clang-rename. clang-rename and all other tools migration can be done later, which is also good in terms of this patch not growing too large.

I'm +1 on making this patch implement a skeleton of clang-refactor, which makes it small, and much easier for review. The patch looks much better now.

clang-refactor/driver/Driver.cpp

11

clang-tidy?

38

s/clan/clang

47

Any reason implementing the command-line options and not using the cl::opt here?

clang-refactor/driver/ModuleManager.h

24 ↗

(On Diff #70373)

StringRef.

clang-refactor/modules/core/RefactoringModule.h

43 ↗

(On Diff #70373)

s/wouold/would/

54 ↗

(On Diff #70373)

"It it" doesn't make sense here.

89 ↗

(On Diff #70373)

I'd make this interface a virtual function too, and provide this default implementation.

128 ↗

(On Diff #70373)

Does the panic mean something like exit(1)? But from the interface, it looks like returning an error code, right?

146 ↗

(On Diff #70373)

A further thought:

applyReplacement is more likely a postprocess step of handleTranslationUnit, what if some clang-refactor subtools just want to dump the results only? I'd prefer to rename it to OnEndOfHandlingTranslationUnit. I'm open to hear better suggestions.

148 ↗

(On Diff #70373)

Use "= default".

150 ↗

(On Diff #70373)

You can return a StringRef here?

152 ↗

(On Diff #70373)

The same.

clang-refactor/modules/template/TemplateModule.h

15 ↗

(On Diff #70373)

Not needed.

20 ↗

(On Diff #70373)

It'd be clear to add a small paragraph describing that this is a template module which is only used to lower the "barrier to entry" for writing clang-refactor subtool.

[omtcyfz]

Addressing a round of comments.

[omtcyfz]

Thank you for reviewing, @hokein!

Also, please note that this is not a final version, the interface will change a lot in the upcoming diffs.

clang-refactor/driver/Driver.cpp

47

I might be mistaken, but it'd require parsing whole option sequence, which should be delegated to the submodules.

E.g. "help" should be only called if the the tool is invoked as clang-refactor --help, but if I parse all options I'd also invoke "help" while having "clang-refactor rename --help" for example. At least that's what I have been thinking.

clang-refactor/modules/core/RefactoringModule.h

89 ↗

(On Diff #70373)

I'll update the interface soonish.

Had an offline discussion with Alex about the interface and we came up to a conclusion that the interface should be way more strict. This one is just a general idea of how it might be implemented.

Thus, run shouldn't be overridden in my opinion, but I'll update the diff and make some high-level comments on that later.

128 ↗

(On Diff #70373)

1. Well, no. I believe that the error should be thrown to the run and "printed out" there.
2. Also, not that we're aiming for a multi-TU multi-threaded architecture in the end (although it doesn't make sense with the current interface, but again, I'll update it later).

146 ↗

(On Diff #70373)

/* comment about multi-TU multi-threaded stuff */

Suppose a refactoring can't be applied to some translation units. Say, "rename" tool encountered name conflict in any TU. In this case the tool should fail and not process the last step.

If your comment is about naming only, I'll change it, too.

clang-refactor/modules/template/TemplateModule.h

15 ↗

(On Diff #70373)

Deleting TemplateModule.

20 ↗

(On Diff #70373)

Deleting TemplateModule.

[curdeius]

For the moment, just a few nitty-gritty comments inline.
What I miss here is (as already pointed by someone) an example on how to write a new module, register it etc.

clang-refactor/driver/Driver.cpp

42

Simpler:

std::string Invocation = argv[0] + (" " + Command);

clang-refactor/driver/ModuleManager.cpp

22–24 ↗

(On Diff #70397)

Using find and then operator[] makes the search twice. IMO, it would be better to avoid that by:

auto it = CommandToModuleID.find(Command);
if (it != CommandToModuleID.end()) {
  return RegisteredModules[*it]->run(argc, argv);
}

clang-refactor/driver/ModuleManager.h

13–19 ↗

(On Diff #70397)

clang-format includes (and make it a single block)?

21 ↗

(On Diff #70397)

using namespace in header?!

clang-refactor/modules/core/RefactoringModule.h

36 ↗

(On Diff #70397)

s/infromation/information

56 ↗

(On Diff #70397)

s/occurance/occurrence

72 ↗

(On Diff #70397)

s/temprorary/temporary

112 ↗

(On Diff #70397)

s/regiestering/registering

[alexfh]

Kirill, first, thank you for working on this!

As discussed offline, the RefactoringModule interface should explicitly define:

• separation of execution stages for each check:
  1. preparation or execution planning - should figure out the set of affected translation units and what should be done for each of them
  2. processing of affected translation units - ideally, this should be done in parallel, separate process per TU, and the interface should not prevent this
  3. application of replacements or error reporting, if stage 2 detected that execution of refactoring is not possible - looks like this is not refactoring-specific and can be done by the clang-refactor framework
• state transferred between stages (since they should allow for independent execution, potentially in multiple processes, so data should be in a serializable form)
• data and facilities available to each stage (e.g. cross-reference index, AST of a certain translation unit, ability to register PPCallbacks, interface to pass data to the next stage, report results or errors)
• basic interfaces for the facilities mentioned above.

A failure to define these aspects would complicate introduction of multi-TU support and require significant changes to refactoring tools to follow a stricter interface.

[alexfh]

clang-refactor/driver/Driver.cpp

42

(llvm::Twine(argv[0]) + " " + ...).str()

clang-refactor/driver/ModuleManager.h

21 ↗

(On Diff #70397)

If you need StringRef, ArrayRef etc. in clang namespace, just include "clang/Basic/LLVM.h".

clang-refactor/modules/core/RefactoringModule.h

91 ↗

(On Diff #70397)

I believe, run should be external to the module. Its implementation might be different depending on whether we're just running all stages sequentially or trying to parallelize processing of different translation units.

148 ↗

(On Diff #70397)

This should be possible to implement in a refactoring-independent way in clang-refactor itself. Or do you see any issues with this?

[omtcyfz]

Addressing few comments.

Major improvements on the way.

[omtcyfz]

clang-refactor/driver/ModuleManager.cpp

22–24 ↗

(On Diff #70397)

The search is O(1) anyway, but the code itself probably becomes more reasonable, thanks.

clang-refactor/driver/ModuleManager.h

13–19 ↗

(On Diff #70397)

I like to separate includes into three groups (LLVM includes, STL includes, subproject includes), which I think is not very bad. Haven't seen any policy prohibiting it. Feel free to elaborate, though.

Sorted the includes within the second group.

clang-refactor/modules/core/RefactoringModule.h

148 ↗

(On Diff #70397)

Nope, totally agree.

[curdeius]

clang-refactor/driver/ModuleManager.h

14–20 ↗

(On Diff #70682)

I thought that idea behind sorting includes using clang-format is to avoid handling groups and order manually.
I don't think that there is any policy prohibiting separating includes into groups, but AFAIK, there is one that says that STL includes should be the last (you should include in order from the most specific to the most generic, i.e. subproject, clang, llvm, STL).

[omtcyfz]

Slightly improve the interface.

Patch is still not complete, though.

[omtcyfz]

The diff doesn't really do much right now, but it kind of gives the idea of what's happening with clang-refactor.

[ioeric]

clang-refactor/driver/ModuleManager.h

14–20 ↗

(On Diff #70682)

Fortunately, clang-format is smart enough to categorize #include groups (e.g. LLVM includes, STL includes, main header etc). We actually encourage people to combine #includes groups into one block and let clang-format handle the categorization (fyi: clang-format only sort includes within a block). The point is to free you from worrying about the formatting.

[arphaman]

clang-refactor/core/SymbolIndexClient.h

31 ↗

(On Diff #71776)

End namespace clang?

[arphaman]

clang-refactor/driver/Driver.cpp

37

Is there a particular reason why you don't return a value that's returned by Manager.dispatch here? It seems odd to me that Manager.dispatch returns an integer value that's not actually used here.

[ioeric]

clang-refactor/driver/Driver.cpp

37

BTW, isn't argv[1] pointing to a temp string above?

[omtcyfz]

No longer relevant.

CMakeLists.txt

 add_subdirectory(clang-apply-replacements)
-add_subdirectory(clang-rename)
+add_subdirectory(clang-refactor)
 add_subdirectory(clang-reorder-fields)
 add_subdirectory(modularize)
 if(CLANG_ENABLE_STATIC_ANALYZER)
 add_subdirectory(clang-tidy)
 endif()
 
 add_subdirectory(clang-query)
 add_subdirectory(include-fixer)
 add_subdirectory(pp-trace)
 add_subdirectory(tool-template)
 
 # Add the common testsuite after all the tools.
 # TODO: Support tests with more granularity when features are off?
 if(CLANG_ENABLE_STATIC_ANALYZER AND CLANG_INCLUDE_TESTS)
 add_subdirectory(test)
 add_subdirectory(unittests)
 endif()
 
 option(CLANG_TOOLS_EXTRA_INCLUDE_DOCS "Generate build targets for the Clang Extra Tools docs."
   ${LLVM_INCLUDE_DOCS})
 if( CLANG_TOOLS_EXTRA_INCLUDE_DOCS )
   add_subdirectory(docs)
 endif()
-

TemplatedClassFunction.cpp

+template <typename T>
+class A {
+public:
+  void foo() /* Test 1 */ {}  // CHECK: void bar() /* Test 1 */ {}
+};
+
+int main(int argc, char **argv) {
+  A<int> a;
+  a.foo();   /* Test 2 */     // CHECK: a.bar()   /* Test 2 */
+  return 0;
+}
+
+// Test 1.
+// RUN: clang-refactor rename -offset=48 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
+// Test 2.
+// RUN: clang-refactor rename -offset=162 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
+//
+// Currently unsupported test.
+// XFAIL: *
+
+// To find offsets after modifying the file, use:
+//   grep -Ubo 'foo.*' <file>

clang-refactor/CMakeLists.txt

+include_directories(
+  USREngine
+  modules
+  )
+
+add_subdirectory(driver)
+add_subdirectory(USREngine)
+add_subdirectory(modules)
+add_subdirectory(editor-integrations)

clang-refactor/USREngine/CMakeLists.txt

-set(LLVM_LINK_COMPONENTS support)
+set(LLVM_LINK_COMPONENTS Support)
 
-add_clang_library(clangRename
+add_clang_library(clangRefactorUSREngine
   USRFinder.cpp
   USRFindingAction.cpp
   USRLocFinder.cpp
-  RenamingAction.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangIndex
   clangLex
-  clangToolingCore
   )
-
-add_subdirectory(tool)

clang-refactor/USREngine/USRFinder.h

-//===--- tools/extra/clang-rename/USRFinder.h - Clang rename tool ---------===//
+//===--- tools/extra/clang-refactor/USRFinder.h - USREngine ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Methods for determining the USR of a symbol at a location in source
 /// code.
 ///
 //===----------------------------------------------------------------------===//
+
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDER_H
 
 #include "clang/AST/AST.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include <string>
 
 using namespace llvm;
 using namespace clang::ast_matchers;
 
 namespace clang {
 class ASTContext;
 class Decl;
 class SourceLocation;
 class NamedDecl;
 
-namespace rename {
+namespace clang_refactor {
 
 // Given an AST context and a point, returns a NamedDecl identifying the symbol
 // at the point. Returns null if nothing is found at the point.
 const NamedDecl *getNamedDeclAt(const ASTContext &Context,
                                 const SourceLocation Point);
 
 // Given an AST context and a fully qualified name, returns a NamedDecl
 // identifying the symbol with a matching name. Returns null if nothing is

clang-refactor/USREngine/USRFinder.cpp

-//===--- tools/extra/clang-rename/USRFinder.cpp - Clang rename tool -------===//
+//===--- tools/extra/clang-refactor/USRFinder.cpp - USREngine -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file Implements a recursive AST visitor that finds the USR of a symbol at a
 /// point.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "USRFinder.h"
 #include "clang/AST/AST.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Index/USRGeneration.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/SmallVector.h"
 
 using namespace llvm;
 
 namespace clang {
-namespace rename {
+namespace clang_refactor {
 
 // NamedDeclFindingASTVisitor recursively visits each AST node to find the
 // symbol underneath the cursor.
 // FIXME: move to seperate .h/.cc file if this gets too large.
 namespace {
 class NamedDeclFindingASTVisitor
     : public clang::RecursiveASTVisitor<NamedDeclFindingASTVisitor> {
 public:
public:
 
   // Other visitors:
 
   bool VisitTypeLoc(const TypeLoc Loc) {
     const SourceLocation TypeBeginLoc = Loc.getBeginLoc();
     const SourceLocation TypeEndLoc = Lexer::getLocForEndOfToken(
         TypeBeginLoc, 0, Context.getSourceManager(), Context.getLangOpts());
     if (const auto *TemplateTypeParm =
-            dyn_cast<TemplateTypeParmType>(Loc.getType())) {
+            dyn_cast<TemplateTypeParmType>(Loc.getType()))
       return setResult(TemplateTypeParm->getDecl(), TypeBeginLoc, TypeEndLoc);
-    }
     if (const auto *TemplateSpecType =
-            dyn_cast<TemplateSpecializationType>(Loc.getType())) {
+            dyn_cast<TemplateSpecializationType>(Loc.getType()))
       return setResult(TemplateSpecType->getTemplateName().getAsTemplateDecl(),
                        TypeBeginLoc, TypeEndLoc);
-    }
     return setResult(Loc.getType()->getAsCXXRecordDecl(), TypeBeginLoc,
                      TypeEndLoc);
   }
 
   bool VisitCXXConstructorDecl(clang::CXXConstructorDecl *ConstructorDecl) {
     for (const auto *Initializer : ConstructorDecl->inits()) {
-      if (!Initializer->isWritten()) {
+      if (!Initializer->isWritten())
         // Ignore implicit initializers.
         continue;
-      }
       if (const clang::FieldDecl *FieldDecl = Initializer->getMember()) {
         const SourceLocation InitBeginLoc = Initializer->getSourceLocation(),
                              InitEndLoc = Lexer::getLocForEndOfToken(
                                  InitBeginLoc, 0, Context.getSourceManager(),
                                  Context.getLangOpts());
-        if (!setResult(FieldDecl, InitBeginLoc, InitEndLoc)) {
+        if (!setResult(FieldDecl, InitBeginLoc, InitEndLoc))
           return false;
-        }
-      }
-    }
     return true;
   }
 
   // Other:
 
   const NamedDecl *getNamedDecl() { return Result; }
 
   // \brief Determines if a namespace qualifier contains the point.
   // \returns false on success and sets Result.
   void handleNestedNameSpecifierLoc(NestedNameSpecifierLoc NameLoc) {
     while (NameLoc) {
       const NamespaceDecl *Decl =
           NameLoc.getNestedNameSpecifier()->getAsNamespace();
       setResult(Decl, NameLoc.getLocalBeginLoc(), NameLoc.getLocalEndLoc());
       NameLoc = NameLoc.getPrefix();
     }
   }
 
 private:
   // \brief Sets Result to Decl if the Point is within Start and End.
   // \returns false on success.
   bool setResult(const NamedDecl *Decl, SourceLocation Start,
                  SourceLocation End) {
-    if (!Decl) {
+    if (!Decl)
       return true;
-    }
     if (Name.empty()) {
       // Offset is used to find the declaration.
       if (!Start.isValid() || !Start.isFileID() || !End.isValid() ||
-          !End.isFileID() || !isPointWithin(Start, End)) {
+          !End.isFileID() || !isPointWithin(Start, End))
         return true;
-      }
     } else {
       // Fully qualified name is used to find the declaration.
-      if (Name != Decl->getQualifiedNameAsString()) {
+      if (Name != Decl->getQualifiedNameAsString())
         return true;
-      }
-    }
     Result = Decl;
     return false;
   }
 
   // \brief Sets Result to Decl if Point is within Loc and Loc + Offset.
   // \returns false on success.
   bool setResult(const NamedDecl *Decl, SourceLocation Loc, unsigned Offset) {
     // FIXME: Add test for Offset == 0. Add test for Offset - 1 (vs -2 etc).
const NamedDecl *getNamedDeclAt(const ASTContext &Context,
   StringRef SearchFile = Context.getSourceManager().getFilename(Point);
   NamedDeclFindingASTVisitor Visitor(Point, Context);
 
   // We only want to search the decls that exist in the same file as the point.
   for (auto *CurrDecl : Context.getTranslationUnitDecl()->decls()) {
     const SourceLocation FileLoc = CurrDecl->getLocStart();
     StringRef FileName = Context.getSourceManager().getFilename(FileLoc);
     // FIXME: Add test.
-    if (FileName == SearchFile) {
+    if (FileName == SearchFile)
       Visitor.TraverseDecl(CurrDecl);
-    }
-  }
 
   NestedNameSpecifierLocFinder Finder(const_cast<ASTContext &>(Context));
-  for (const auto &Location : Finder.getNestedNameSpecifierLocations()) {
+  for (const auto &Location : Finder.getNestedNameSpecifierLocations())
     Visitor.handleNestedNameSpecifierLoc(Location);
-  }
 
   return Visitor.getNamedDecl();
 }
 
 const NamedDecl *getNamedDeclFor(const ASTContext &Context,
                                  const std::string &Name) {
   NamedDeclFindingASTVisitor Visitor(Name, Context);
   Visitor.TraverseDecl(Context.getTranslationUnitDecl());
 
   return Visitor.getNamedDecl();
 }
 
 std::string getUSRForDecl(const Decl *Decl) {
   llvm::SmallVector<char, 128> Buff;
 
   // FIXME: Add test for the nullptr case.
   if (Decl == nullptr || index::generateUSRForDecl(Decl, Buff))
     return "";
 
   return std::string(Buff.data(), Buff.size());
 }
 
-} // namespace rename
+} // namespace clang_refactor
 } // namespace clang

clang-refactor/USREngine/USRFindingAction.h

+//===--- tools/extra/clang-refactor/USRFindingAction.h - USREngine --------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Provides an action to find all relevant USRs at a point.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_REFACTOR_USRENGINE_USRFINDINGACTION_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_REFACTOR_USRENGINE_USRFINDINGACTION_H
+
+#include "clang/AST/ASTTypeTraits.h"
+#include "clang/Frontend/FrontendAction.h"
+
+#include <string>
+#include <vector>
+
+namespace clang {
+class ASTConsumer;
+class CompilerInstance;
+class NamedDecl;
+
+namespace clang_refactor {
+
+struct USRFindingAction {
+  USRFindingAction(ArrayRef<unsigned> SymbolOffsets,
+                   ArrayRef<std::string> QualifiedNames)
+      : SymbolOffsets(SymbolOffsets), QualifiedNames(QualifiedNames) {}
+  std::unique_ptr<ASTConsumer> newASTConsumer();
+
+  const std::vector<std::string> &getUSRSpellings() { return SpellingNames; }
+  const std::vector<std::vector<std::string>> &getUSRList() { return USRList; }
+
+private:
+  std::vector<unsigned> SymbolOffsets;
+  std::vector<std::string> QualifiedNames;
+  std::vector<std::string> SpellingNames;
+  std::vector<std::vector<std::string>> USRList;
+};
+
+} // namespace clang_refactor
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_REFACTOR_USRENGINE_USRFINDINGACTION_H

clang-refactor/USREngine/USRFindingAction.cpp

-//===--- tools/extra/clang-rename/USRFindingAction.cpp - Clang rename tool ===//
+//===--- tools/extra/clang-refactor/USRFindingAction.cpp - USREngine ------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Provides an action to find USR for the symbol at <offset>, as well as
 /// all additional USRs.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "USRFindingAction.h"
 #include "USRFinder.h"
 #include "clang/AST/AST.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Tooling.h"
 #include <algorithm>
 #include <set>
-#include <string>
-#include <vector>
 
 using namespace llvm;
 
 namespace clang {
-namespace rename {
+namespace clang_refactor {
 
 namespace {
 // \brief NamedDeclFindingConsumer should delegate finding USRs of given Decl to
 // AdditionalUSRFinder. AdditionalUSRFinder adds USRs of ctor and dtor if given
 // Decl refers to class and adds USRs of all overridden methods if Decl refers
 // to virtual method.
 class AdditionalUSRFinder : public RecursiveASTVisitor<AdditionalUSRFinder> {
 public:
-  explicit AdditionalUSRFinder(const Decl *FoundDecl, ASTContext &Context,
-                               std::vector<std::string> *USRs)
-      : FoundDecl(FoundDecl), Context(Context), USRs(USRs) {}
+  explicit AdditionalUSRFinder(const Decl *FoundDecl, ASTContext &Context)
+      : FoundDecl(FoundDecl), Context(Context) {}
 
-  void Find() {
+  std::vector<std::string> Find() {
     // Fill OverriddenMethods and PartialSpecs storages.
     TraverseDecl(Context.getTranslationUnitDecl());
     if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(FoundDecl)) {
       addUSRsOfOverridenFunctions(MethodDecl);
-      for (const auto &OverriddenMethod : OverriddenMethods) {
-        if (checkIfOverriddenFunctionAscends(OverriddenMethod)) {
+      for (const auto &OverriddenMethod : OverriddenMethods)
+        if (checkIfOverriddenFunctionAscends(OverriddenMethod))
           USRSet.insert(getUSRForDecl(OverriddenMethod));
-        }
-      }
     } else if (const auto *RecordDecl = dyn_cast<CXXRecordDecl>(FoundDecl)) {
       handleCXXRecordDecl(RecordDecl);
     } else if (const auto *TemplateDecl =
                    dyn_cast<ClassTemplateDecl>(FoundDecl)) {
       handleClassTemplateDecl(TemplateDecl);
     } else {
       USRSet.insert(getUSRForDecl(FoundDecl));
     }
-    USRs->insert(USRs->end(), USRSet.begin(), USRSet.end());
+    return std::vector<std::string>(USRSet.begin(), USRSet.end());
   }
 
   bool VisitCXXMethodDecl(const CXXMethodDecl *MethodDecl) {
-    if (MethodDecl->isVirtual()) {
+    if (MethodDecl->isVirtual())
       OverriddenMethods.push_back(MethodDecl);
-    }
     return true;
   }
 
   bool VisitClassTemplatePartialSpecializationDecl(
       const ClassTemplatePartialSpecializationDecl *PartialSpec) {
     PartialSpecs.push_back(PartialSpec);
     return true;
   }
 
 private:
   void handleCXXRecordDecl(const CXXRecordDecl *RecordDecl) {
     RecordDecl = RecordDecl->getDefinition();
     if (const auto *ClassTemplateSpecDecl =
-            dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl)) {
+            dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl))
       handleClassTemplateDecl(ClassTemplateSpecDecl->getSpecializedTemplate());
-    }
+
     addUSRsOfCtorDtors(RecordDecl);
   }
 
   void handleClassTemplateDecl(const ClassTemplateDecl *TemplateDecl) {
-    for (const auto *Specialization : TemplateDecl->specializations()) {
+    for (const auto *Specialization : TemplateDecl->specializations())
       addUSRsOfCtorDtors(Specialization);
-    }
-    for (const auto *PartialSpec : PartialSpecs) {
-      if (PartialSpec->getSpecializedTemplate() == TemplateDecl) {
+
+    for (const auto *PartialSpec : PartialSpecs)
+      if (PartialSpec->getSpecializedTemplate() == TemplateDecl)
         addUSRsOfCtorDtors(PartialSpec);
-      }
-    }
     addUSRsOfCtorDtors(TemplateDecl->getTemplatedDecl());
   }
 
   void addUSRsOfCtorDtors(const CXXRecordDecl *RecordDecl) {
     RecordDecl = RecordDecl->getDefinition();
-    for (const auto *CtorDecl : RecordDecl->ctors()) {
+    for (const auto *CtorDecl : RecordDecl->ctors())
       USRSet.insert(getUSRForDecl(CtorDecl));
-    }
     USRSet.insert(getUSRForDecl(RecordDecl->getDestructor()));
     USRSet.insert(getUSRForDecl(RecordDecl));
   }
 
   void addUSRsOfOverridenFunctions(const CXXMethodDecl *MethodDecl) {
     USRSet.insert(getUSRForDecl(MethodDecl));
-    for (const auto &OverriddenMethod : MethodDecl->overridden_methods()) {
+    for (const auto &OverriddenMethod : MethodDecl->overridden_methods())
       // Recursively visit each OverridenMethod.
       addUSRsOfOverridenFunctions(OverriddenMethod);
-    }
-  }
 
   bool checkIfOverriddenFunctionAscends(const CXXMethodDecl *MethodDecl) {
     for (const auto &OverriddenMethod : MethodDecl->overridden_methods()) {
-      if (USRSet.find(getUSRForDecl(OverriddenMethod)) != USRSet.end()) {
+      if (USRSet.find(getUSRForDecl(OverriddenMethod)) != USRSet.end())
         return true;
-      }
       return checkIfOverriddenFunctionAscends(OverriddenMethod);
     }
     return false;
   }
 
   const Decl *FoundDecl;
   ASTContext &Context;
-  std::vector<std::string> *USRs;
   std::set<std::string> USRSet;
   std::vector<const CXXMethodDecl *> OverriddenMethods;
   std::vector<const ClassTemplatePartialSpecializationDecl *> PartialSpecs;
 };
 } // namespace
 
-struct NamedDeclFindingConsumer : public ASTConsumer {
-  void HandleTranslationUnit(ASTContext &Context) override {
-    const SourceManager &SourceMgr = Context.getSourceManager();
-    // The file we look for the USR in will always be the main source file.
+class NamedDeclFindingConsumer : public ASTConsumer {
+public:
+  explicit NamedDeclFindingConsumer(
+      ArrayRef<unsigned> SymbolOffsets, ArrayRef<std::string> QualifiedNames,
+      std::vector<std::string> &SpellingNames,
+      std::vector<std::vector<std::string>> &USRList)
+      : SymbolOffsets(SymbolOffsets), QualifiedNames(QualifiedNames),
+        SpellingNames(SpellingNames), USRList(USRList) {
+  }
+
+private:
+  void FindSymbol(ASTContext &Context, const SourceManager &SourceMgr,
+                  unsigned SymbolOffset, const std::string &QualifiedName) {
     const SourceLocation Point =
         SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID())
             .getLocWithOffset(SymbolOffset);
+
     if (!Point.isValid())
       return;
     const NamedDecl *FoundDecl = nullptr;
-    if (OldName.empty()) {
+
+    if (QualifiedName.empty())
       FoundDecl = getNamedDeclAt(Context, Point);
-    } else {
-      FoundDecl = getNamedDeclFor(Context, OldName);
-    }
+    else
+      FoundDecl = getNamedDeclFor(Context, QualifiedName);
+
     if (FoundDecl == nullptr) {
-      if (OldName.empty()) {
+      if (QualifiedName.empty()) {
         FullSourceLoc FullLoc(Point, SourceMgr);
-        errs() << "clang-rename: could not find symbol at "
+        errs() << "clang-refactor rename: could not find symbol at "
                << SourceMgr.getFilename(Point) << ":"
                << FullLoc.getSpellingLineNumber() << ":"
                << FullLoc.getSpellingColumnNumber() << " (offset "
                << SymbolOffset << ").\n";
-      } else
-        errs() << "clang-rename: could not find symbol " << OldName << ".\n";
+        exit(1);
+      } else {
+        errs() << "USREngine: could not find symbol " << QualifiedName << ".\n";
+        exit(1);
+      }
       return;
     }
 
-    // If FoundDecl is a constructor or destructor, we want to instead take the
-    // Decl of the corresponding class.
-    if (const auto *CtorDecl = dyn_cast<CXXConstructorDecl>(FoundDecl)) {
+    // If FoundDecl is a constructor or destructor, we want to instead take
+    // the Decl of the corresponding class.
+    if (const auto *CtorDecl = dyn_cast<CXXConstructorDecl>(FoundDecl))
       FoundDecl = CtorDecl->getParent();
-    } else if (const auto *DtorDecl = dyn_cast<CXXDestructorDecl>(FoundDecl)) {
+    else if (const auto *DtorDecl = dyn_cast<CXXDestructorDecl>(FoundDecl))
       FoundDecl = DtorDecl->getParent();
-    }
-    *SpellingName = FoundDecl->getNameAsString();
+
+    SpellingNames.push_back(FoundDecl->getNameAsString());
+    AdditionalUSRFinder Finder(FoundDecl, Context);
+    USRList.push_back(Finder.Find());
 
-    AdditionalUSRFinder Finder(FoundDecl, Context, USRs);
-    Finder.Find();
+  void HandleTranslationUnit(ASTContext &Context) override {
+    const SourceManager &SourceMgr = Context.getSourceManager();
+    for (unsigned Offset : SymbolOffsets)
+      FindSymbol(Context, SourceMgr, Offset, "");
+    for (const std::string &QualifiedName : QualifiedNames)
+      FindSymbol(Context, SourceMgr, 0, QualifiedName);
   }
 
-  unsigned SymbolOffset;
-  std::string OldName;
-  std::string *SpellingName;
-  std::vector<std::string> *USRs;
+  ArrayRef<unsigned> SymbolOffsets;
+  ArrayRef<std::string> QualifiedNames;
+  std::vector<std::string> &SpellingNames;
+  std::vector<std::vector<std::string>> &USRList;
 };
 
 std::unique_ptr<ASTConsumer> USRFindingAction::newASTConsumer() {
-  std::unique_ptr<NamedDeclFindingConsumer> Consumer(
-      new NamedDeclFindingConsumer);
-  SpellingName = "";
-  Consumer->SymbolOffset = SymbolOffset;
-  Consumer->OldName = OldName;
-  Consumer->USRs = &USRs;
-  Consumer->SpellingName = &SpellingName;
-  return std::move(Consumer);
+  return llvm::make_unique<NamedDeclFindingConsumer>(
+      SymbolOffsets, QualifiedNames, SpellingNames, USRList);
 }
 
-} // namespace rename
+} // namespace clang_refactor
 } // namespace clang

clang-refactor/USREngine/USRLocFinder.h

-//===--- tools/extra/clang-rename/USRLocFinder.h - Clang rename tool ------===//
+//===--- tools/extra/clang-refactor/USRLocFinder.h - USREngine ------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Provides functionality for finding all instances of a USR in a given
 /// AST.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_LOC_FINDER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_LOC_FINDER_H
 
 #include "clang/AST/AST.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 #include <vector>
 
 namespace clang {
-namespace rename {
+namespace clang_refactor {
 
 // FIXME: make this an AST matcher. Wouldn't that be awesome??? I agree!
 std::vector<SourceLocation>
 getLocationsOfUSRs(const std::vector<std::string> &USRs,
                    llvm::StringRef PrevName, Decl *Decl);
 
-} // namespace rename
+} // namespace clang_refactor
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_LOC_FINDER_H

clang-refactor/USREngine/USRLocFinder.cpp

-//===--- tools/extra/clang-rename/USRLocFinder.cpp - Clang rename tool ----===//
+//===--- tools/extra/clang-refactor/USRLocFinder.cpp - USREngine ----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///

 #include "clang/Basic/SourceLocation.h"
 #include "clang/Index/USRGeneration.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/SmallVector.h"
 
 using namespace llvm;
 
 namespace clang {
-namespace rename {
+namespace clang_refactor {
 
 namespace {
 // \brief This visitor recursively searches for all instances of a USR in a
 // translation unit and stores them for later usage.
 class USRLocFindingASTVisitor
     : public clang::RecursiveASTVisitor<USRLocFindingASTVisitor> {
 public:
   explicit USRLocFindingASTVisitor(const std::vector<std::string> &USRs,
                                    StringRef PrevName,
                                    const ASTContext &Context)
       : USRSet(USRs.begin(), USRs.end()), PrevName(PrevName), Context(Context) {
   }
 
   // Declaration visitors:
 
   bool VisitCXXConstructorDecl(clang::CXXConstructorDecl *ConstructorDecl) {
     for (const auto *Initializer : ConstructorDecl->inits()) {
-      if (!Initializer->isWritten()) {
+      if (!Initializer->isWritten())
         // Ignore implicit initializers.
         continue;
-      }
       if (const clang::FieldDecl *FieldDecl = Initializer->getMember()) {
-        if (USRSet.find(getUSRForDecl(FieldDecl)) != USRSet.end()) {
+        if (USRSet.find(getUSRForDecl(FieldDecl)) != USRSet.end())
           LocationsFound.push_back(Initializer->getSourceLocation());
-        }
-      }
-    }
     return true;
   }
 
   bool VisitNamedDecl(const NamedDecl *Decl) {
-    if (USRSet.find(getUSRForDecl(Decl)) != USRSet.end()) {
+    if (USRSet.find(getUSRForDecl(Decl)) != USRSet.end())
       checkAndAddLocation(Decl->getLocation());
-    }
     return true;
   }
 
   // Expression visitors:
 
   bool VisitDeclRefExpr(const DeclRefExpr *Expr) {
     const NamedDecl *Decl = Expr->getFoundDecl();
 
bool VisitMemberExpr(const MemberExpr *Expr) {
     }
     return true;
   }
 
   // Other visitors:
 
   bool VisitTypeLoc(const TypeLoc Loc) {
     if (USRSet.find(getUSRForDecl(Loc.getType()->getAsCXXRecordDecl())) !=
-        USRSet.end()) {
+        USRSet.end())
       checkAndAddLocation(Loc.getBeginLoc());
-    }
+
     if (const auto *TemplateTypeParm =
             dyn_cast<TemplateTypeParmType>(Loc.getType())) {
       if (USRSet.find(getUSRForDecl(TemplateTypeParm->getDecl())) !=
-          USRSet.end()) {
+          USRSet.end())
         checkAndAddLocation(Loc.getBeginLoc());
-      }
-    }
     return true;
   }
 
   // Non-visitors:
 
   // \brief Returns a list of unique locations. Duplicate or overlapping
   // locations are erroneous and should be reported!
   const std::vector<clang::SourceLocation> &getLocationsFound() const {
     return LocationsFound;
   }
 
   // Namespace traversal:
   void handleNestedNameSpecifierLoc(NestedNameSpecifierLoc NameLoc) {
     while (NameLoc) {
       const NamespaceDecl *Decl =
           NameLoc.getNestedNameSpecifier()->getAsNamespace();
-      if (Decl && USRSet.find(getUSRForDecl(Decl)) != USRSet.end()) {
+      if (Decl && USRSet.find(getUSRForDecl(Decl)) != USRSet.end())
         checkAndAddLocation(NameLoc.getLocalBeginLoc());
-      }
       NameLoc = NameLoc.getPrefix();
     }
   }
 
 private:
   void checkAndAddLocation(SourceLocation Loc) {
     const SourceLocation BeginLoc = Loc;
     const SourceLocation EndLoc = Lexer::getLocForEndOfToken(
         BeginLoc, 0, Context.getSourceManager(), Context.getLangOpts());
     StringRef TokenName =
         Lexer::getSourceText(CharSourceRange::getTokenRange(BeginLoc, EndLoc),
                              Context.getSourceManager(), Context.getLangOpts());
     size_t Offset = TokenName.find(PrevName);
-    if (Offset != StringRef::npos) {
+    if (Offset != StringRef::npos)
       // The token of the source location we find actually has the old
       // name.
       LocationsFound.push_back(BeginLoc.getLocWithOffset(Offset));
-    }
-  }
 
   const std::set<std::string> USRSet;
   const std::string PrevName;
   std::vector<clang::SourceLocation> LocationsFound;
   const ASTContext &Context;
 };
 } // namespace
 
 std::vector<SourceLocation>
 getLocationsOfUSRs(const std::vector<std::string> &USRs, StringRef PrevName,
                    Decl *Decl) {
   USRLocFindingASTVisitor Visitor(USRs, PrevName, Decl->getASTContext());
   Visitor.TraverseDecl(Decl);
   NestedNameSpecifierLocFinder Finder(Decl->getASTContext());
-  for (const auto &Location : Finder.getNestedNameSpecifierLocations()) {
+  for (const auto &Location : Finder.getNestedNameSpecifierLocations())
     Visitor.handleNestedNameSpecifierLoc(Location);
-  }
   return Visitor.getLocationsFound();
 }
 
-} // namespace rename
+} // namespace clang_refactor
 } // namespace clang

clang-refactor/driver/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  Support
+  )
+
+add_clang_executable(clang-refactor
+  Driver.cpp
+  )
+
+target_link_libraries(clang-refactor
+  clangAST
+  clangBasic
+  clangFrontend
+  clangTooling
+
+  clangRefactorRenameModule
+
+  clangRefactorUSREngine
+  )

clang-refactor/driver/ClangRefactorOptions.h

+//===--- tools/extra/clang-refactor/ClangRefactorOptions.h ----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Defines common options for clang-refactor subtools.
+///
+//===----------------------------------------------------------------------===//
+
+#include "clang/Tooling/CommonOptionsParser.h"
+
+#ifndef CLANG_REFACTOR_OPTIONS_H
+#define CLANG_REFACTOR_OPTIONS_H
+
+using namespace llvm;
+
+namespace clang {
+namespace clang_refactor {
+
+// FIXME: Adjust libTooling so that these options would be displayed, too.
+static cl::OptionCategory
+    ClangRefactorCommonOptions("clang-refactor common options");
+
+static cl::list<unsigned> SymbolOffsets(
+    "offset",
+    cl::desc("Locates the symbol by offset as opposed to <line>:<column>."),
+    cl::ZeroOrMore, cl::cat(ClangRefactorCommonOptions));
+static cl::opt<bool> Inplace("i", cl::desc("Overwrite edited <file>s."),
+                      cl::cat(ClangRefactorCommonOptions));
+static cl::list<std::string>
+    QualifiedNames("qualified-name",
+                   cl::desc("The fully qualified name of the symbol."),
+                   cl::ZeroOrMore, cl::cat(ClangRefactorCommonOptions));
+
+namespace rename_module {
+
+static cl::OptionCategory
+    ClangRefactorRenameCategory("clang-refactor rename options");
+
+static cl::list<std::string>
+    NewNames("new-name", cl::desc("The new name to change the symbol to."),
+             cl::ZeroOrMore, cl::cat(ClangRefactorRenameCategory));
+static cl::opt<bool> PrintName(
+    "pn",
+    cl::desc("Print the found symbol's name prior to renaming to stderr."),
+    cl::cat(ClangRefactorRenameCategory));
+static cl::opt<bool> PrintLocations(
+    "pl", cl::desc("Print the locations affected by renaming to stderr."),
+    cl::cat(ClangRefactorRenameCategory));
+static cl::opt<std::string> ExportFixes(
+    "export-fixes", cl::desc("YAML file to store suggested fixes in."),
+    cl::value_desc("filename"), cl::cat(ClangRefactorRenameCategory));
+static cl::opt<std::string>
+    Input("input", cl::desc("YAML file to load oldname-newname pairs from."),
+          cl::Optional, cl::cat(ClangRefactorRenameCategory));
+
+} // namespace rename_module
+
+} // namespace clang_refactor
+} // namespace clang
+
+#endif // CLANG_REFACTOR_OPTIONS_H

clang-refactor/driver/Driver.cpp

+//===---- tools/extra/clang-refactor/Driver.cpp - clang-refactor driver ---===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  \file This file implements clang-refactor driver.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Rename.h"
+
+#include "llvm/ADT/StringSwitch.h"
+
+#include <functional>
+#include <string>
+
+using namespace clang;
+using namespace llvm;
+
+const char HelpMessage[] =
+    "USAGE: clang-refactor [subcommand] [options] <source0> [... <sourceN>]\n"
+    "\n"
+    "Subcommands:\n"
+    "  rename: rename the symbol found at <offset>s or by <qualified-name>s in "
+    "<source0>.\n";
+
+static int printHelpMessage(int argc, const char *argv[]) {
+  outs() << HelpMessage;
+  return 0;
+}
+
+int main(int argc, const char **argv) {
+  if (argc > 1) {
+    using MainFunction = std::function<int(int, const char *[])>;
+    MainFunction Func =
+        StringSwitch<MainFunction>(argv[1])
+            .Cases("-help", "--help", printHelpMessage)
+            .Case("rename", clang_refactor::rename_module::RenameModuleMain)
+            .Default(nullptr);
+    if (Func) {
+      std::string Invocation = std::string(argv[0]) + " " + argv[1];
+      argv[1] = Invocation.c_str();
+      return Func(argc - 1, argv + 1);
+    }
+  }
+
+  printHelpMessage(argc, argv);
+  return 0;
+}

clang-refactor/driver/Rename.h

+//===--- tools/extra/clang-refactor/Rename.h - rename module driver -------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file implements driver of rename module of clang-refactor.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_REFACTOR_RENAME_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_REFACTOR_RENAME_H
+
+#include "USRFindingAction.h"
+#include "rename/RenamingAction.h"
+#include "ClangRefactorOptions.h"
+
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Basic/FileManager.h"
+#include "clang/Basic/IdentifierTable.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Basic/TokenKinds.h"
+#include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/Rewrite/Core/Rewriter.h"
+#include "clang/Tooling/CommonOptionsParser.h"
+#include "clang/Tooling/Refactoring.h"
+#include "clang/Tooling/ReplacementsYaml.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/YAMLTraits.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cstdlib>
+#include <string>
+#include <system_error>
+
+using namespace llvm;
+using namespace clang;
+
+/// \brief An oldname -> newname rename.
+struct RenameAllInfo {
+  unsigned Offset = 0;
+  std::string OldName;
+  std::string NewName;
+};
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(RenameAllInfo)
+
+namespace llvm {
+namespace yaml {
+
+/// \brief Specialized MappingTraits to describe how a RenameAllInfo is
+/// (de)serialized.
+template <> struct MappingTraits<RenameAllInfo> {
+  static void mapping(IO &IO, RenameAllInfo &Info) {
+    IO.mapOptional("Offset", Info.Offset);
+    IO.mapOptional("OldName", Info.OldName);
+    IO.mapRequired("NewName", Info.NewName);
+  }
+};
+
+} // end namespace yaml
+} // end namespace llvm
+
+namespace clang {
+namespace clang_refactor {
+namespace rename_module {
+
+int RenameModuleMain(int argc, const char **argv) {
+  tooling::CommonOptionsParser OP(argc, argv, ClangRefactorRenameCategory);
+
+  if (!Input.empty()) {
+    // Populate QualifiedNames and NewNames from a YAML file.
+    ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
+        llvm::MemoryBuffer::getFile(Input);
+    if (!Buffer) {
+      errs() << "clang-refactor rename: failed to read " << Input << ": "
+             << Buffer.getError().message() << "\n";
+      return 1;
+    }
+
+    std::vector<RenameAllInfo> Infos;
+    llvm::yaml::Input YAML(Buffer.get()->getBuffer());
+    YAML >> Infos;
+    for (const auto &Info : Infos) {
+      if (!Info.OldName.empty())
+        QualifiedNames.push_back(Info.OldName);
+      else
+        SymbolOffsets.push_back(Info.Offset);
+      NewNames.push_back(Info.NewName);
+    }
+  }
+
+  // Check the arguments for correctness.
+  if (NewNames.empty()) {
+    errs() << "clang-refactor rename: -new-name or -input is required.\n\n";
+    exit(1);
+  }
+
+  // Check if NewNames is a valid identifier in C++17.
+  LangOptions Options;
+  Options.CPlusPlus = true;
+  Options.CPlusPlus1z = true;
+  IdentifierTable Table(Options);
+  for (const auto &NewName : NewNames) {
+    auto NewNameTokKind = Table.get(NewName).getTokenID();
+    if (!tok::isAnyIdentifier(NewNameTokKind)) {
+      errs() << "ERROR: new name is not a valid identifier in C++17.\n\n";
+      exit(1);
+    }
+  }
+
+  if (SymbolOffsets.size() + QualifiedNames.size() != NewNames.size()) {
+    errs() << "clang-refactor rename: number of symbol offsets("
+           << SymbolOffsets.size() << ") + number of qualified names ("
+           << QualifiedNames.size() << ") must be equal to number of new names("
+           << NewNames.size() << ").\n\n";
+    cl::PrintHelpMessage();
+    exit(1);
+  }
+
+  auto Files = OP.getSourcePathList();
+  tooling::RefactoringTool Tool(OP.getCompilations(), Files);
+  USRFindingAction FindingAction(SymbolOffsets, QualifiedNames);
+  Tool.run(tooling::newFrontendActionFactory(&FindingAction).get());
+  const std::vector<std::vector<std::string>> &USRList =
+      FindingAction.getUSRList();
+  const std::vector<std::string> &PrevNames = FindingAction.getUSRSpellings();
+  if (PrintName) {
+    for (const auto &PrevName : PrevNames) {
+      outs() << "clang-refactor rename found name: " << PrevName << '\n';
+    }
+  }
+
+  // Perform the renaming.
+  RenamingAction RenameAction(NewNames, PrevNames, USRList,
+                              Tool.getReplacements(), PrintLocations);
+  std::unique_ptr<tooling::FrontendActionFactory> Factory =
+      tooling::newFrontendActionFactory(&RenameAction);
+  int ExitCode;
+
+  if (Inplace) {
+    ExitCode = Tool.runAndSave(Factory.get());
+  } else {
+    ExitCode = Tool.run(Factory.get());
+
+    if (!ExportFixes.empty()) {
+      std::error_code EC;
+      llvm::raw_fd_ostream OS(ExportFixes, EC, llvm::sys::fs::F_None);
+      if (EC) {
+        llvm::errs() << "Error opening output file: " << EC.message() << '\n';
+        exit(1);
+      }
+
+      // Export replacements.
+      tooling::TranslationUnitReplacements TUR;
+      const auto &FileToReplacements = Tool.getReplacements();
+      for (const auto &Entry : FileToReplacements)
+        TUR.Replacements.insert(TUR.Replacements.end(), Entry.second.begin(),
+                                Entry.second.end());
+
+      yaml::Output YAML(OS);
+      YAML << TUR;
+      OS.close();
+      exit(0);
+    }
+
+    // Write every file to stdout. Right now we just barf the files without any
+    // indication of which files start where, other than that we print the files
+    // in the same order we see them.
+    LangOptions DefaultLangOptions;
+    IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+    TextDiagnosticPrinter DiagnosticPrinter(errs(), &*DiagOpts);
+    DiagnosticsEngine Diagnostics(
+        IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
+        &DiagnosticPrinter, false);
+    auto &FileMgr = Tool.getFiles();
+    SourceManager Sources(Diagnostics, FileMgr);
+    Rewriter Rewrite(Sources, DefaultLangOptions);
+
+    Tool.applyAllReplacements(Rewrite);
+    for (const auto &File : Files) {
+      const auto *Entry = FileMgr.getFile(File);
+      auto ID = Sources.translateFile(Entry);
+      Rewrite.getEditBuffer(ID).write(outs());
+    }
+  }
+
+  exit(ExitCode);
+}
+
+} // namespace rename_module
+} // namespace clang_refactor
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_REFACTOR_RENAME_H

clang-refactor/editor-integrations/CMakeLists.txt

+install(PROGRAMS clang-refactor-rename.py
+  DESTINATION share/clang
+  COMPONENT clang-refactor)
+install(PROGRAMS clang-refactor-rename.el
+  DESTINATION share/clang
+  COMPONENT clang-refactor)

clang-refactor/editor-integrations/clang-refactor-rename.el

-;;; clang-rename.el --- Renames every occurrence of a symbol found at <offset>.
+;;; clang-refactor-rename.el --- Renames symbols found at <offset>.
 
 ;; Keywords: tools, c
 
 ;;; Commentary:
 
-;; To install clang-rename.el make sure the directory of this file is in your
-;; 'load-path' and add
+;; To install clang-refactor-rename.el make sure the directory of this file is
+;; in your 'load-path' and add
 ;;
-;;   (require 'clang-rename)
+;;   (require 'clang-refactor-rename)
 ;;
 ;; to your .emacs configuration.
 
 ;;; Code:
 
-(defcustom clang-rename-binary "clang-rename"
-  "Path to clang-rename executable."
+(defcustom clang-refactor "clang-refactor"
+  "Path to clang-refactor executable."
   :type 'hook
   :options '(turn-on-auto-fill flyspell-mode)
   :group 'wp)
 
-(defun clang-rename (new-name)
-  "Rename all instances of the symbol at the point using clang-rename"
+(defun clang-refactor-rename (new-name)
+  "Rename all instances of the symbol at the point using clang-refactor rename"
   (interactive "sEnter a new name: ")
   (let (;; Emacs offset is 1-based.
         (offset (- (point) 1))
         (orig-buf (current-buffer))
         (file-name (buffer-file-name)))
 
     (let ((rename-command
           (format "bash -f -c '%s -offset=%s -new-name=%s -i %s'"
-                               clang-rename-binary offset new-name file-name)))
-          (message (format "Running clang-rename command %s" rename-command))
-          ;; Run clang-rename via bash.
+                               clang-refactor-binary offset new-name file-name)))
+          (message (format "Running clang-refactor command %s" rename-command))
+          ;; Run clang-refactor via bash.
           (shell-command rename-command)
           ;; Reload buffer.
           (revert-buffer t t)
     )
   )
 )
 
-(provide 'clang-rename)
+(provide 'clang-refactor)
 
-;;; clang-rename.el ends here
+;;; clang-refactor.el ends here

clang-refactor/editor-integrations/clang-refactor-rename.py

 '''
-Minimal clang-rename integration with Vim.
+Minimal clang-refactor rename integration with Vim.
 
 Before installing make sure one of the following is satisfied:
 
-* clang-rename is in your PATH
-* `g:clang_rename_path` in ~/.vimrc points to valid clang-rename executable
-* `binary` in clang-rename.py points to valid to clang-rename executable
+* clang-refactor is in your PATH
+* `g:clang_rename_path` in ~/.vimrc points to valid clang-refactor executable
+* `binary` in clang-refactor rename.py points to valid to clang-refactor
+executable
 
 To install, simply put this into your ~/.vimrc
 
-    noremap <leader>cr :pyf <path-to>/clang-rename.py<cr>
+    noremap <leader>cr :pyf <path-to>/clang-refactor-rename.py<cr>
 
 IMPORTANT NOTE: Before running the tool, make sure you saved the file.
 
 All you have to do now is to place a cursor on a variable/function/class which
 you would like to rename and press '<leader>cr'. You will be prompted for a new
 name if the cursor points to a valid symbol.
 '''
 
 import vim
 import subprocess
 import sys
 
 def main():
-    binary = 'clang-rename'
+    binary = 'clang-refactor'
     if vim.eval('exists("g:clang_rename_path")') == "1":
         binary = vim.eval('g:clang_rename_path')
 
-    # Get arguments for clang-rename binary.
+    # Get arguments for clang-refactor binary.
     offset = int(vim.eval('line2byte(line("."))+col(".")')) - 2
     if offset < 0:
         print >> sys.stderr, '''Couldn\'t determine cursor position.
                                 Is your file empty?'''
         return
     filename = vim.current.buffer.name
 
     new_name_request_message = 'type new name:'
     new_name = vim.eval("input('{}\n')".format(new_name_request_message))
 
-    # Call clang-rename.
+    # Call clang-refactor rename module.
     command = [binary,
                filename,
+               'rename',
                '-i',
                '-offset', str(offset),
                '-new-name', str(new_name)]
     # FIXME: make it possible to run the tool on unsaved file.
     p = subprocess.Popen(command,
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
     stdout, stderr = p.communicate()

clang-refactor/modules/CMakeLists.txt

+add_subdirectory(rename)

clang-refactor/modules/rename/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS Support)
+
+add_clang_library(clangRefactorRenameModule
+  RenamingAction.cpp
+
+  LINK_LIBS
+  clangAST
+  clangBasic
+  clangFrontend
+  clangToolingCore
+
+  clangRefactorUSREngine
+  )

clang-refactor/modules/rename/RenamingAction.h

-//===--- tools/extra/clang-rename/RenamingAction.h - Clang rename tool ----===//
+//===--- tools/extra/clang-refactor/RenamingAction.h ----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Provides an action to rename every symbol at a point.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_RENAMING_ACTION_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_RENAMING_ACTION_H
 
 #include "clang/Tooling/Refactoring.h"
 
 namespace clang {
 class ASTConsumer;
 class CompilerInstance;
 
-namespace rename {
+namespace clang_refactor {
+namespace rename_module {
 
 class RenamingAction {
 public:
   RenamingAction(const std::vector<std::string> &NewNames,
                  const std::vector<std::string> &PrevNames,
                  const std::vector<std::vector<std::string>> &USRList,
                  std::map<std::string, tooling::Replacements> &FileToReplaces,
                  bool PrintLocations = false)
       : NewNames(NewNames), PrevNames(PrevNames), USRList(USRList),
         FileToReplaces(FileToReplaces), PrintLocations(PrintLocations) {}
 
   std::unique_ptr<ASTConsumer> newASTConsumer();
 
 private:
   const std::vector<std::string> &NewNames, &PrevNames;
   const std::vector<std::vector<std::string>> &USRList;
   std::map<std::string, tooling::Replacements> &FileToReplaces;
   bool PrintLocations;
 };
-}
-}
+
+} // namespace rename_module
+} // namespace clang_refactor
+} // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_RENAMING_ACTION_H

clang-refactor/modules/rename/RenamingAction.cpp

-//===--- tools/extra/clang-rename/RenamingAction.cpp - Clang rename tool --===//
+//===--- tools/extra/clang-refactor/RenamingAction.cpp --------------------===//
 //
 //                     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.h"
 #include "clang/Tooling/Tooling.h"
 #include <string>
 #include <vector>
 
 using namespace llvm;
 
 namespace clang {
-namespace rename {
+namespace clang_refactor {
+namespace rename_module {
 
 class RenamingASTConsumer : public ASTConsumer {
 public:
   RenamingASTConsumer(
       const std::vector<std::string> &NewNames,
       const std::vector<std::string> &PrevNames,
       const std::vector<std::vector<std::string>> &USRList,
       std::map<std::string, tooling::Replacements> &FileToReplaces,
NewCandidates =
         getLocationsOfUSRs(USRs, PrevName, Context.getTranslationUnitDecl());
     RenamingCandidates.insert(RenamingCandidates.end(), NewCandidates.begin(),
                               NewCandidates.end());
 
     unsigned PrevNameLen = PrevName.length();
     for (const auto &Loc : RenamingCandidates) {
       if (PrintLocations) {
         FullSourceLoc FullLoc(Loc, SourceMgr);
-        errs() << "clang-rename: renamed at: " << SourceMgr.getFilename(Loc)
-               << ":" << FullLoc.getSpellingLineNumber() << ":"
+        errs() << "clang-refactor rename: renamed at: "
+               << SourceMgr.getFilename(Loc) << ":"
+               << FullLoc.getSpellingLineNumber() << ":"
                << FullLoc.getSpellingColumnNumber() << "\n";
       }
       // FIXME: better error handling.
       tooling::Replacement Replace(SourceMgr, Loc, PrevNameLen, NewName);
       llvm::Error Err = FileToReplaces[Replace.getFilePath()].add(Replace);
       if (Err)
         llvm::errs() << "Renaming failed in " << Replace.getFilePath() << "! "
                      << llvm::toString(std::move(Err)) << "\n";
     }
   }
 
 private:
   const std::vector<std::string> &NewNames, &PrevNames;
   const std::vector<std::vector<std::string>> &USRList;
   std::map<std::string, tooling::Replacements> &FileToReplaces;
   bool PrintLocations;
 };
 
 std::unique_ptr<ASTConsumer> RenamingAction::newASTConsumer() {
   return llvm::make_unique<RenamingASTConsumer>(NewNames, PrevNames, USRList,
                                                 FileToReplaces, PrintLocations);
 }
 
-} // namespace rename
+} // namespace rename_module
+} // namespace clang_refactor
 } // namespace clang

clang-rename/USRFindingAction.h

-//===--- tools/extra/clang-rename/USRFindingAction.h - Clang rename tool --===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief Provides an action to find all relevant USRs at a point.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDING_ACTION_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDING_ACTION_H
-
-#include "clang/Frontend/FrontendAction.h"
-
-namespace clang {
-class ASTConsumer;
-class CompilerInstance;
-class NamedDecl;
-
-namespace rename {
-
-struct USRFindingAction {
-  USRFindingAction(unsigned Offset, const std::string &Name)
-      : SymbolOffset(Offset), OldName(Name) {}
-  std::unique_ptr<ASTConsumer> newASTConsumer();
-
-  // \brief get the spelling of the USR(s) as it would appear in source files.
-  const std::string &getUSRSpelling() { return SpellingName; }
-
-  const std::vector<std::string> &getUSRs() { return USRs; }
-
-private:
-  unsigned SymbolOffset;
-  std::string OldName;
-  std::string SpellingName;
-  std::vector<std::string> USRs;
-};
-
-} // namespace rename
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDING_ACTION_H

clang-rename/tool/CMakeLists.txt

-add_clang_executable(clang-rename ClangRename.cpp)
-
-target_link_libraries(clang-rename
-  clangBasic
-  clangFrontend
-  clangRename
-  clangRewrite
-  clangTooling
-  clangToolingCore
-  )
-
-install(TARGETS clang-rename RUNTIME DESTINATION bin)
-
-install(PROGRAMS clang-rename.py
-  DESTINATION share/clang
-  COMPONENT clang-rename)
-install(PROGRAMS clang-rename.el
-  DESTINATION share/clang
-  COMPONENT clang-rename)

clang-rename/tool/ClangRename.cpp

-//===--- tools/extra/clang-rename/ClangRename.cpp - Clang rename tool -----===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief This file implements a clang-rename tool that automatically finds and
-/// renames symbols in C++ code.
-///
-//===----------------------------------------------------------------------===//
-
-#include "../RenamingAction.h"
-#include "../USRFindingAction.h"
-#include "clang/Basic/Diagnostic.h"
-#include "clang/Basic/DiagnosticOptions.h"
-#include "clang/Basic/FileManager.h"
-#include "clang/Basic/IdentifierTable.h"
-#include "clang/Basic/LangOptions.h"
-#include "clang/Basic/SourceManager.h"
-#include "clang/Basic/TokenKinds.h"
-#include "clang/Frontend/TextDiagnosticPrinter.h"
-#include "clang/Rewrite/Core/Rewriter.h"
-#include "clang/Tooling/CommonOptionsParser.h"
-#include "clang/Tooling/Refactoring.h"
-#include "clang/Tooling/ReplacementsYaml.h"
-#include "clang/Tooling/Tooling.h"
-#include "llvm/ADT/IntrusiveRefCntPtr.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/YAMLTraits.h"
-#include "llvm/Support/raw_ostream.h"
-#include <cstdlib>
-#include <string>
-#include <system_error>
-
-using namespace llvm;
-
-using namespace clang;
-
-cl::OptionCategory ClangRenameAtCategory("clang-rename rename-at options");
-cl::OptionCategory ClangRenameAllCategory("clang-rename rename-all options");
-
-const char RenameAtUsage[] = "A tool to rename symbols in C/C++ code.\n\
-clang-rename renames every occurrence of a symbol found at <offset> in\n\
-<source0>. If -i is specified, the edited files are overwritten to disk.\n\
-Otherwise, the results are written to stdout.\n";
-
-const char RenameAllUsage[] = "A tool to rename symbols in C/C++ code.\n\
-clang-rename performs renaming given pairs {offset | old-name} -> new-name.\n";
-
-static int renameAtMain(int argc, const char *argv[]);
-static int renameAllMain(int argc, const char *argv[]);
-static int helpMain(int argc, const char *argv[]);
-
-/// \brief An oldname -> newname rename.
-struct RenameAllInfo {
-  std::string OldName;
-  unsigned Offset = 0;
-  std::string NewName;
-};
-
-LLVM_YAML_IS_SEQUENCE_VECTOR(RenameAllInfo)
-
-namespace llvm {
-namespace yaml {
-
-/// \brief Specialized MappingTraits to describe how a RenameAllInfo is
-/// (de)serialized.
-template <> struct MappingTraits<RenameAllInfo> {
-  static void mapping(IO &IO, RenameAllInfo &Info) {
-    IO.mapOptional("OldName", Info.OldName);
-    IO.mapOptional("Offset", Info.Offset);
-    IO.mapRequired("NewName", Info.NewName);
-  }
-};
-
-} // end namespace yaml
-} // end namespace llvm
-
-int main(int argc, const char **argv) {
-  if (argc > 1) {
-    using MainFunction = std::function<int(int, const char *[])>;
-    MainFunction Func = StringSwitch<MainFunction>(argv[1])
-                            .Case("rename-at", renameAtMain)
-                            .Case("rename-all", renameAllMain)
-                            .Cases("-help", "--help", helpMain)
-                            .Default(nullptr);
-
-    if (Func) {
-      std::string Invocation = std::string(argv[0]) + " " + argv[1];
-      argv[1] = Invocation.c_str();
-      return Func(argc - 1, argv + 1);
-    } else {
-      return renameAtMain(argc, argv);
-    }
-  }
-
-  helpMain(argc, argv);
-  return 1;
-}
-
-int subcommandMain(bool isRenameAll, int argc, const char **argv) {
-  cl::OptionCategory *Category = nullptr;
-  const char *Usage = nullptr;
-  if (isRenameAll) {
-    Category = &ClangRenameAllCategory;
-    Usage = RenameAllUsage;
-  } else {
-    Category = &ClangRenameAtCategory;
-    Usage = RenameAtUsage;
-  }
-
-  cl::list<std::string> NewNames(
-      "new-name", cl::desc("The new name to change the symbol to."),
-      (isRenameAll ? cl::ZeroOrMore : cl::Required), cl::cat(*Category));
-  cl::list<unsigned> SymbolOffsets(
-      "offset",
-      cl::desc("Locates the symbol by offset as opposed to <line>:<column>."),
-      (isRenameAll ? cl::ZeroOrMore : cl::Required), cl::cat(*Category));
-  cl::list<std::string> OldNames(
-      "old-name",
-      cl::desc(
-          "The fully qualified name of the symbol, if -offset is not used."),
-      (isRenameAll ? cl::ZeroOrMore : cl::Optional),
-      cl::cat(ClangRenameAllCategory));
-  cl::opt<bool> Inplace("i", cl::desc("Overwrite edited <file>s."),
-                        cl::cat(*Category));
-  cl::opt<bool> PrintName(
-      "pn",
-      cl::desc("Print the found symbol's name prior to renaming to stderr."),
-      cl::cat(ClangRenameAtCategory));
-  cl::opt<bool> PrintLocations(
-      "pl", cl::desc("Print the locations affected by renaming to stderr."),
-      cl::cat(ClangRenameAtCategory));
-  cl::opt<std::string> ExportFixes(
-      "export-fixes", cl::desc("YAML file to store suggested fixes in."),
-      cl::value_desc("filename"), cl::cat(*Category));
-  cl::opt<std::string> Input(
-      "input", cl::desc("YAML file to load oldname-newname pairs from."),
-      cl::Optional, cl::cat(ClangRenameAllCategory));
-
-  tooling::CommonOptionsParser OP(argc, argv, *Category, Usage);
-
-  if (!Input.empty()) {
-    // Populate OldNames and NewNames from a YAML file.
-    ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
-        llvm::MemoryBuffer::getFile(Input);
-    if (!Buffer) {
-      errs() << "clang-rename: failed to read " << Input << ": "
-             << Buffer.getError().message() << "\n";
-      return 1;
-    }
-
-    std::vector<RenameAllInfo> Infos;
-    llvm::yaml::Input YAML(Buffer.get()->getBuffer());
-    YAML >> Infos;
-    for (const auto &Info : Infos) {
-      if (!Info.OldName.empty())
-        OldNames.push_back(Info.OldName);
-      else
-        SymbolOffsets.push_back(Info.Offset);
-      NewNames.push_back(Info.NewName);
-    }
-  }
-
-  // Check the arguments for correctness.
-
-  if (NewNames.empty()) {
-    errs() << "clang-rename: either -new-name or -input is required.\n\n";
-    exit(1);
-  }
-
-  // Check if NewNames is a valid identifier in C++17.
-  for (const auto &NewName : NewNames) {
-    LangOptions Options;
-    Options.CPlusPlus = true;
-    Options.CPlusPlus1z = true;
-    IdentifierTable Table(Options);
-    auto NewNameTokKind = Table.get(NewName).getTokenID();
-    if (!tok::isAnyIdentifier(NewNameTokKind)) {
-      errs() << "ERROR: new name is not a valid identifier in C++17.\n\n";
-      exit(1);
-    }
-  }
-
-  if (!OldNames.empty() && OldNames.size() != NewNames.size()) {
-    errs() << "clang-rename: number of old names (" << OldNames.size()
-           << ") do not equal to number of new names (" << NewNames.size()
-           << ").\n\n";
-    cl::PrintHelpMessage();
-    exit(1);
-  }
-
-  if (!SymbolOffsets.empty() && SymbolOffsets.size() != NewNames.size()) {
-    errs() << "clang-rename: number of symbol offsets (" << SymbolOffsets.size()
-           << ") do not equal to number of new names (" << NewNames.size()
-           << ").\n\n";
-    cl::PrintHelpMessage();
-    exit(1);
-  }
-
-  std::vector<std::vector<std::string>> USRList;
-  std::vector<std::string> PrevNames;
-  auto Files = OP.getSourcePathList();
-  tooling::RefactoringTool Tool(OP.getCompilations(), Files);
-  unsigned Count = OldNames.size() ? OldNames.size() : SymbolOffsets.size();
-  for (unsigned I = 0; I < Count; ++I) {
-    unsigned SymbolOffset = SymbolOffsets.empty() ? 0 : SymbolOffsets[I];
-    const std::string &OldName = OldNames.empty() ? std::string() : OldNames[I];
-
-    // Get the USRs.
-    rename::USRFindingAction USRAction(SymbolOffset, OldName);
-
-    // Find the USRs.
-    Tool.run(tooling::newFrontendActionFactory(&USRAction).get());
-    const auto &USRs = USRAction.getUSRs();
-    USRList.push_back(USRs);
-    const auto &PrevName = USRAction.getUSRSpelling();
-    PrevNames.push_back(PrevName);
-
-    if (PrevName.empty()) {
-      // An error should have already been printed.
-      exit(1);
-    }
-
-    if (PrintName) {
-      errs() << "clang-rename: found name: " << PrevName << '\n';
-    }
-  }
-
-  // Perform the renaming.
-  rename::RenamingAction RenameAction(NewNames, PrevNames, USRList,
-                                      Tool.getReplacements(), PrintLocations);
-  auto Factory = tooling::newFrontendActionFactory(&RenameAction);
-  int ExitCode;
-
-  if (Inplace) {
-    ExitCode = Tool.runAndSave(Factory.get());
-  } else {
-    ExitCode = Tool.run(Factory.get());
-
-    if (!ExportFixes.empty()) {
-      std::error_code EC;
-      llvm::raw_fd_ostream OS(ExportFixes, EC, llvm::sys::fs::F_None);
-      if (EC) {
-        llvm::errs() << "Error opening output file: " << EC.message() << '\n';
-        exit(1);
-      }
-
-      // Export replacements.
-      tooling::TranslationUnitReplacements TUR;
-      const auto &FileToReplacements = Tool.getReplacements();
-      for (const auto &Entry : FileToReplacements)
-        TUR.Replacements.insert(TUR.Replacements.end(), Entry.second.begin(),
-                                Entry.second.end());
-
-      yaml::Output YAML(OS);
-      YAML << TUR;
-      OS.close();
-      exit(0);
-    }
-
-    // Write every file to stdout. Right now we just barf the files without any
-    // indication of which files start where, other than that we print the files
-    // in the same order we see them.
-    LangOptions DefaultLangOptions;
-    IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
-    TextDiagnosticPrinter DiagnosticPrinter(errs(), &*DiagOpts);
-    DiagnosticsEngine Diagnostics(
-        IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
-        &DiagnosticPrinter, false);
-    auto &FileMgr = Tool.getFiles();
-    SourceManager Sources(Diagnostics, FileMgr);
-    Rewriter Rewrite(Sources, DefaultLangOptions);
-
-    Tool.applyAllReplacements(Rewrite);
-    for (const auto &File : Files) {
-      const auto *Entry = FileMgr.getFile(File);
-      auto ID = Sources.translateFile(Entry);
-      Rewrite.getEditBuffer(ID).write(outs());
-    }
-  }
-
-  exit(ExitCode);
-}
-
-/// \brief Top level help.
-/// FIXME It would be better if this could be auto-generated.
-static int helpMain(int argc, const char *argv[]) {
-  errs() << "Usage: clang-rename {rename-at|rename-all} [OPTION]...\n\n"
-            "A tool to rename symbols in C/C++ code.\n\n"
-            "Subcommands:\n"
-            "  rename-at:  Perform rename off of a location in a file. (This "
-            "is the default.)\n"
-            "  rename-all: Perform rename of all symbols matching one or more "
-            "fully qualified names.\n";
-  return 0;
-}
-
-static int renameAtMain(int argc, const char *argv[]) {
-  return subcommandMain(false, argc, argv);
-}
-
-static int renameAllMain(int argc, const char *argv[]) {
-  return subcommandMain(true, argc, argv);
-}

docs/clang-refactor/index.rst

+==============
+Clang-Refactor
+==============
+
+.. contents::
+
+See also:
+
+.. toctree::
+   :maxdepth: 1
+
+:program:`clang-refactor` is a Clang-based refactoring "master" tool. It is home
+for refactoring submodules, such as `rename`. :program:`clang-refactor` is only
+a prototype at the moment and most of its parts may significantly change.
+
+.. code-block:: console
+
+  $ clang-refactor --help
+
+  USAGE: clang-refactor [subcommand] [options] <source0> [... <sourceN>]
+
+  Subcommands:
+    rename: rename the symbol found at <offset>s or by <qualified-name>s in <source0>.
+
+=======
+Modules
+=======
+
+.. toctree::
+   :maxdepth: 1
+
+   rename.rst

docs/clang-refactor/rename.rst

+======
+Rename
+======
+
+.. contents::
+
+See also:
+
+.. toctree::
+   :maxdepth: 1
+
+
+`rename` is a module of `clang-refactor`, a C++ "master" refactoring tool. Its
+purpose is to perform efficient renaming actions in large-scale projects such as
+renaming classes, functions, variables, arguments, namespaces etc.
+
+The tool is in a very early development stage, so you might encounter bugs and
+crashes. Submitting reports with information about how to reproduce the issue
+to `the LLVM bugtracker <https://llvm.org/bugs>`_ will definitely help the
+project. If you have any ideas or suggestions, you might want to put a feature
+request there.
+
+Using Rename module
+===================
+
+:program:`clang-refactor` is a `LibTooling
+<http://clang.llvm.org/docs/LibTooling.html>`_-based tool, and it's easier to
+work with if you set up a compile command database for your project (for an
+example of how to do this see `How To Setup Tooling For LLVM
+<http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html>`_). You can also
+specify compilation options on the command line after `--`:
+
+.. code-block:: console
+
+  $ clang-refactor rename -offset=42 -new-name=foo test.cpp -- -Imy_project/include -DMY_DEFINES ...
+
+
+To get an offset of a symbol in a file run
+
+.. code-block:: console
+
+  $ grep -FUbo 'foo' file.cpp
+
+
+The tool currently supports renaming actions inside a single translation unit
+only. It is planned to extend the tool's functionality to support multi-TU
+renaming actions in the future.
+
+:program:`clang-refactor` also aims to be easily integrated into popular text
+editors, such as Vim and Emacs, and improve the workflow of users.
+
+Although a command line interface exists, it is highly recommended to use the
+text editor interface instead for better experience.
+
+You can also identify one or more symbols to be renamed by giving the fully
+qualified name:
+
+.. code-block:: console
+
+  $ clang-refactor rename-old-name=foo -new-name=bar test.cpp
+
+
+Alternatively, { offset | old name } -> new name pairs can be put into a YAML
+file:
+
+.. code-block:: yaml
+
+  ---
+  - OldName:        foo
+    NewName:        bar
+  - Offset:         42
+    NewName:        baz
+  ...
+
+
+That way you can avoid spelling out all the names as command line arguments:
+
+.. code-block:: console
+
+  $ clang-refactor rename -input=test.yaml test.cpp
+
+
+Vim Integration
+===============
+
+You can call :program:`clang-refactor rename` directly from Vim! To set up
+:program:`clang-refactor-rename` integration for Vim see
+`clang-refactor/editor-integrations/clang-refactor-rename.py
+<http://reviews.llvm.org/diffusion/L/browse/clang-tools-extra/trunk/clang-refactor/editor-integrations/clang-refactor-rename.py>`_.
+
+Please note that **you have to save all buffers, in which the replacement will
+happen before running the tool**.
+
+Once installed, you can point your cursor to symbols you want to rename, press
+`<leader>cr` and type new desired name. The `<leader> key
+<http://vim.wikia.com/wiki/Mapping_keys_in_Vim_-_Tutorial_(Part_3)#Map_leader>`_
+is a reference to a specific key defined by the mapleader variable and is bound
+to backslash by default.
+
+Emacs Integration
+=================
+
+You can also use :program:`clang-refactor` while using Emacs! To set up
+:program:`clang-refactor rename` integration for Emacs see
+`clang-refactor/editor-integrations/clang-refactor-rename.el
+<http://reviews.llvm.org/diffusion/L/browse/clang-tools-extra/trunk/clang-refactor/editor-integrations/clang-refactor-rename.el>`_.
+
+Once installed, you can point your cursor to symbols you want to rename, press
+`M-X`, type `clang-refactor rename` and new desired name.
+
+Please note that **you have to save all buffers, in which the replacement will
+happen before running the tool**.

docs/clang-rename.rst

-============
-Clang-Rename
-============
-
-.. contents::
-
-See also:
-
-.. toctree::
-   :maxdepth: 1
-
-
-:program:`clang-rename` is a C++ refactoring tool. Its purpose is to perform
-efficient renaming actions in large-scale projects such as renaming classes,
-functions, variables, arguments, namespaces etc.
-
-The tool is in a very early development stage, so you might encounter bugs and
-crashes. Submitting reports with information about how to reproduce the issue
-to `the LLVM bugtracker <https://llvm.org/bugs>`_ will definitely help the
-project. If you have any ideas or suggestions, you might want to put a feature
-request there.
-
-Using Clang-Rename
-==================
-
-:program:`clang-rename` is a `LibTooling
-<http://clang.llvm.org/docs/LibTooling.html>`_-based tool, and it's easier to
-work with if you set up a compile command database for your project (for an
-example of how to do this see `How To Setup Tooling For LLVM
-<http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html>`_). You can also
-specify compilation options on the command line after `--`:
-
-.. code-block:: console
-
-  $ clang-rename -offset=42 -new-name=foo test.cpp -- -Imy_project/include -DMY_DEFINES ...
-
-
-To get an offset of a symbol in a file run
-
-.. code-block:: console
-
-  $ grep -FUbo 'foo' file.cpp
-
-
-The tool currently supports renaming actions inside a single translation unit
-only. It is planned to extend the tool's functionality to support multi-TU
-renaming actions in the future.
-
-:program:`clang-rename` also aims to be easily integrated into popular text
-editors, such as Vim and Emacs, and improve the workflow of users.
-
-Although a command line interface exists, it is highly recommended to use the
-text editor interface instead for better experience.
-
-You can also identify one or more symbols to be renamed by giving the fully qualified
-name:
-
-.. code-block:: console
-
-  $ clang-rename rename-all -old-name=foo -new-name=bar test.cpp
-
-
-Alternatively, old name / new name pairs can be put into a YAML file:
-
-.. code-block:: yaml
-
-  ---
-  - OldName:        foo
-    NewName:        bar
-  ...
-
-
-That way you can avoid spelling out all the names as command line arguments:
-
-.. code-block:: console
-
-  $ clang-rename rename-all -input=test.yaml test.cpp
-
-
-The YAML file also supports offsets:
-
-.. code-block:: yaml
-
-  ---
-  - Offset:         42
-    NewName:        foo
-  ...
-
-
-:program:`clang-rename` offers the following options:
-
-.. code-block:: console
-
-  $ clang-rename -help
-  Usage: clang-rename {rename-at|rename-all} [OPTION]...
-
-  A tool to rename symbols in C/C++ code.
-
-  Subcommands:
-    rename-at:  Perform rename off of a location in a file. (This is the default.)
-    rename-all: Perform rename of all symbols matching one or more fully qualified names.
-
-
-.. code-block:: console
-
-  $ clang-rename rename-at -help
-  OVERVIEW: A tool to rename symbols in C/C++ code.
-  clang-rename renames every occurrence of a symbol found at <offset> in
-  <source0>. If -i is specified, the edited files are overwritten to disk.
-  Otherwise, the results are written to stdout.
-  
-  USAGE: clang-rename rename-at [subcommand] [options] <source0> [... <sourceN>]
-  
-  OPTIONS:
-  
-  Generic Options:
-  
-    -help                      - Display available options (-help-hidden for more)
-    -help-list                 - Display list of available options (-help-list-hidden for more)
-    -version                   - Display the version of this program
-
-  clang-rename rename-at options:
-
-    -export-fixes=<filename>   - YAML file to store suggested fixes in.
-    -extra-arg=<string>        - Additional argument to append to the compiler command line.
-    -extra-arg-before=<string> - Additional argument to prepend to the compiler command line.
-    -i                         - Overwrite edited <file>s.
-    -new-name=<string>         - The new name to change the symbol to.
-    -offset=<uint>             - Locates the symbol by offset as opposed to <line>:<column>.
-    -p=<string>                - Build path.
-    -pl                        - Print the locations affected by renaming to stderr.
-    -pn                        - Print the found symbol's name prior to renaming to stderr.
-
-
-.. code-block:: console
-
-  $ clang-rename rename-all -help
-  OVERVIEW: A tool to rename symbols in C/C++ code.
-  clang-rename renames every occurrence of a symbol named <old-name>.
-
-  USAGE: clang-rename rename-all [subcommand] [options] <source0> [... <sourceN>]
-
-  OPTIONS:
-
-  Generic Options:
-
-    -help                      - Display available options (-help-hidden for more).
-    -help-list                 - Display list of available options (-help-list-hidden for more).
-    -version                   - Display the version of this program.
-
-  clang-rename rename-all options:
-
-    -export-fixes=<filename>   - YAML file to store suggested fixes in.
-    -extra-arg=<string>        - Additional argument to append to the compiler command line.
-    -extra-arg-before=<string> - Additional argument to prepend to the compiler command line.
-    -i                         - Overwrite edited <file>s.
-    -input=<string>            - YAML file to load oldname-newname pairs from.
-    -new-name=<string>         - The new name to change the symbol to.
-    -offset=<uint>             - Locates the symbol by offset as opposed to <line>:<column>.
-    -old-name=<string>         - The fully qualified name of the symbol, if -offset is not used.
-    -p=<string>                - Build path.
-
-
-Vim Integration
-===============
-
-You can call :program:`clang-rename` directly from Vim! To set up
-:program:`clang-rename` integration for Vim see
-`clang-rename/tool/clang-rename.py
-<http://reviews.llvm.org/diffusion/L/browse/clang-tools-extra/trunk/clang-rename/tool/clang-rename.py>`_.
-
-Please note that **you have to save all buffers, in which the replacement will
-happen before running the tool**.
-
-Once installed, you can point your cursor to symbols you want to rename, press
-`<leader>cr` and type new desired name. The `<leader> key
-<http://vim.wikia.com/wiki/Mapping_keys_in_Vim_-_Tutorial_(Part_3)#Map_leader>`_
-is a reference to a specific key defined by the mapleader variable and is bound
-to backslash by default.
-
-Emacs Integration
-=================
-
-You can also use :program:`clang-rename` while using Emacs! To set up
-:program:`clang-rename` integration for Emacs see
-`clang-rename/tool/clang-rename.el
-<http://reviews.llvm.org/diffusion/L/browse/clang-tools-extra/trunk/clang-rename/tool/clang-rename.el>`_.
-
-Once installed, you can point your cursor to symbols you want to rename, press
-`M-X`, type `clang-rename` and new desired name.
-
-Please note that **you have to save all buffers, in which the replacement will
-happen before running the tool**.

docs/index.rst

 ========
 .. toctree::
    :maxdepth: 2
 
    clang-tidy/index
    include-fixer
    modularize
    pp-trace
-   clang-rename
+   clang-refactor/index
 
 
 Doxygen Documentation
 =====================
 The Doxygen documentation describes the **internal** software that makes up the
 tools of clang-tools-extra, not the **external** use of these tools. The Doxygen
 documentation contains no instructions about how to use the tools, only the APIs
 that make up the software. For usage instructions, please see the user's guide

test/CMakeLists.txt

set(CLANG_TOOLS_TEST_DEPS
 
   # For the clang-tidy libclang integration test.
   c-index-test
 
   # Individual tools we test.
   clang-apply-replacements
   clang-include-fixer
   clang-query
-  clang-rename
+  clang-refactor
   clang-reorder-fields
   clang-tidy
   find-all-symbols
   modularize
   pp-trace
 
   # Unit tests
   ExtraToolsUnitTests

test/clang-refactor/rename/ClassAsTemplateArgument.cpp

 class Foo /* Test 1 */ {};    // CHECK: class Bar /* Test 1 */ {};
 
 template <typename T>
 void func() {}
 
 template <typename T>
 class Baz {};
 
 int main() {
   func<Foo>();                // CHECK: func<Bar>();
   Baz<Foo> /* Test 2 */ obj;  // CHECK: Baz<Bar> /* Test 2 */ obj;
   return 0;
 }
 
 // Test 1.
-// RUN: clang-rename -offset=7 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=7 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=215 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=215 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'Foo.*' <file>

test/clang-refactor/rename/ClassFindByName.cpp

 class Foo {         // CHECK: class Bar {
 };
 
 int main() {
   Foo *Pointer = 0; // CHECK: Bar *Pointer = 0;
   return 0;
 }
 
 // Test 1.
-// RUN: clang-rename rename-all -old-name=Foo -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -qualified-name=Foo -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s

test/clang-refactor/rename/ClassReplacements.cpp

 // RUN: rm -rf %t
 // RUN: mkdir -p %t/fixes
 // RUN: cat %s > %t.cpp
-// RUN: clang-rename -offset=254 -new-name=Bar -export-fixes=%t/fixes/clang-rename.yaml %t.cpp --
+// RUN: clang-refactor rename -offset=273 -new-name=Bar -export-fixes=%t/fixes/clang-refactor-rename.yaml %t.cpp --
 // RUN: clang-apply-replacements %t
 // RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
 
 class Foo {}; // CHECK: class Bar {};
 
 // Use grep -FUbo 'Foo' <file> to get the correct offset of Cla when changing
 // this file.

test/clang-refactor/rename/ClassSimpleRenaming.cpp

 class Foo /* Test 1 */ {              // CHECK: class Bar /* Test 1 */ {
 public:
   void foo(int x);
 };
 
 void Foo::foo(int x) /* Test 2 */ {}  // CHECK: void Bar::foo(int x) /* Test 2 */ {}
 
 // Test 1.
-// RUN: clang-rename -offset=6 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=6 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=109 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=109 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'Foo.*' <file>

test/clang-refactor/rename/ClassTestMulti.cpp

 class Foo1 /* Offset 1 */ { // CHECK: class Bar1 /* Offset 1 */ {
 };
 
 class Foo2 /* Offset 2 */ { // CHECK: class Bar2 /* Offset 2 */ {
 };
 
 // Test 1.
-// RUN: clang-rename rename-all -offset=6 -new-name=Bar1 -offset=76 -new-name=Bar2 %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename  -offset=6 -new-name=Bar1 -offset=76 -new-name=Bar2 %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'Foo.*' <file>

test/clang-refactor/rename/ClassTestMultiByName.cpp

+class Foo1 { // CHECK: class Bar1
+};
+
+class Foo2 { // CHECK: class Bar2
+};
+
+// Test 1.
+// RUN: clang-refactor rename -qualified-name=Foo1 -new-name=Bar1 -qualified-name=Foo2 -new-name=Bar2 %s -- | sed 's,//.*,,' | FileCheck %s

test/clang-refactor/rename/ClassTestMultiByNameYAML.cpp

+class Foo1 { // CHECK: class Bar1
+};
+
+class Foo2 { // CHECK: class Bar2
+};
+
+// Test 1.
+// RUN: clang-refactor rename  -input %S/Inputs/ClassTestMultiByNameYAMLRenameAll.yaml %s -- | sed 's,//.*,,' | FileCheck %s
+// Test 2.
+// RUN: clang-refactor rename  -input %S/Inputs/ClassTestMultiByNameYAMLRenameAt.yaml %s -- | sed 's,//.*,,' | FileCheck %s

test/clang-refactor/rename/ComplexFunctionOverride.cpp

int main() {
   D d;
   d.foo();                              // CHECK: d.bar();
   E e;
   e.foo();                              // CHECK: e.bar();
   return 0;
 }
 
 // Test 1.
-// RUN: clang-rename -offset=26 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=26 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=109 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=109 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 3.
-// RUN: clang-rename -offset=201 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=201 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 4.
-// RUN: clang-rename -offset=293 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=293 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 5.
-// RUN: clang-rename -offset=385 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=385 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'foo.*' <file>

test/clang-refactor/rename/ComplicatedClassType.cpp

int main() {
   dynamic_cast<const Foo *>(BazPointer)->getValue();      /* Test 4 */ // CHECK: dynamic_cast<const Bar *>(BazPointer)->getValue();
   reinterpret_cast<const Foo *>(BazPointer)->getValue();  /* Test 5 */ // CHECK: reinterpret_cast<const Bar *>(BazPointer)->getValue();
   static_cast<const Foo &>(BazReference).getValue();      /* Test 6 */ // CHECK: static_cast<const Bar &>(BazReference).getValue();
   static_cast<const Foo *>(BazPointer)->getValue();       /* Test 7 */ // CHECK: static_cast<const Bar *>(BazPointer)->getValue();
   return 0;
 }
 
 // Test 1.
-// RUN: clang-rename -offset=30 -new-name=Bar %s -- -frtti | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=30 -new-name=Bar %s -- -frtti | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=155 -new-name=Bar %s -- -frtti | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=155 -new-name=Bar %s -- -frtti | sed 's,//.*,,' | FileCheck %s
 // Test 3.
-// RUN: clang-rename -offset=1133 -new-name=Bar %s -- -frtti | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=1133 -new-name=Bar %s -- -frtti | sed 's,//.*,,' | FileCheck %s
 // Test 4.
-// RUN: clang-rename -offset=1266 -new-name=Bar %s -- -frtti | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=1266 -new-name=Bar %s -- -frtti | sed 's,//.*,,' | FileCheck %s
 // Test 5.
-// RUN: clang-rename -offset=1402 -new-name=Bar %s -- -frtti | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=1402 -new-name=Bar %s -- -frtti | sed 's,//.*,,' | FileCheck %s
 // Test 6.
-// RUN: clang-rename -offset=1533 -new-name=Bar %s -- -frtti | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=1533 -new-name=Bar %s -- -frtti | sed 's,//.*,,' | FileCheck %s
 // Test 7.
-// RUN: clang-rename -offset=1665 -new-name=Bar %s -- -frtti | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=1665 -new-name=Bar %s -- -frtti | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'Foo.*' <file>

test/clang-refactor/rename/Ctor.cpp

 class Foo {                   // CHECK: class Bar {
 public:
   Foo();    /* Test 1 */      // CHECK: Bar();
 };
 
 Foo::Foo()  /* Test 2 */ {}   // CHECK: Bar::Bar()  /* Test 2 */ {}
 
 // Test 1.
-// RUN: clang-rename -offset=62 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=62 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=116 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=116 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'Foo.*' <file>

test/clang-refactor/rename/CtorInitializer.cpp

 class Baz {};
 
 class Qux {
   Baz Foo;         /* Test 1 */       // CHECK: Baz Bar;
 public:
   Qux();
 };
 
 Qux::Qux() : Foo() /* Test 2 */ {}    // CHECK: Qux::Qux() : Bar() /* Test 2 */ {}
 
 // Test 1.
-// RUN: clang-rename -offset=33 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=33 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=118 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=118 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'Foo.*' <file>

test/clang-refactor/rename/DeclRefExpr.cpp

 class C {
 public:
   static int Foo; /* Test 1 */  // CHECK: static int Bar;
 };
 
 int foo(int x) { return 0; }
 #define MACRO(a) foo(a)
 
 int main() {
   C::Foo = 1;     /* Test 2 */  // CHECK: C::Bar = 1;
   MACRO(C::Foo);                // CHECK: MACRO(C::Bar);
   int y = C::Foo; /* Test 3 */  // CHECK: int y = C::Bar;
   return 0;
 }
 
 // Test 1.
-// RUN: clang-rename -offset=31 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=31 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=152 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=152 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 3.
-// RUN: clang-rename -offset=271 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=271 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'Foo.*' <file>

test/clang-refactor/rename/Field.cpp

 class Baz {
   int Foo; /* Test 1 */ // CHECK: int Bar;
 public:
   Baz();
 };
 
 Baz::Baz() : Foo(0) /* Test 2 */ {}  // CHECK: Baz::Baz() : Bar(0)
 
 // Test 1.
-// RUN: clang-rename -offset=18 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=18 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=89 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=89 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'Foo.*' <file>

test/clang-refactor/rename/FunctionMacro.cpp

 #define moo foo           // CHECK: #define moo macro_function
 
 int foo() /* Test 1 */ {  // CHECK: int macro_function() /* Test 1 */ {
   return 42;
 }
 
 void boo(int value) {}
 
 void qoo() {
   foo();                  // CHECK: macro_function();
   boo(foo());             // CHECK: boo(macro_function());
   moo();
   boo(moo());
 }
 
 // Test 1.
-// RUN: clang-rename -offset=68 -new-name=macro_function %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=68 -new-name=macro_function %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'foo.*' <file>

test/clang-refactor/rename/FunctionOverride.cpp

 class A { virtual void foo();     /* Test 1 */ }; // CHECK: class A { virtual void bar();
 class B : public A { void foo();  /* Test 2 */ }; // CHECK: class B : public A { void bar();
 class C : public B { void foo();  /* Test 3 */ }; // CHECK: class C : public B { void bar();
 
 // Test 1.
-// RUN: clang-rename -offset=23 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=23 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=116 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=116 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 3.
-// RUN: clang-rename -offset=209 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=209 -new-name=bar %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'foo.*' <file>

test/clang-refactor/rename/FunctionWithClassFindByName.cpp

 void foo() {
 }
 
 class Foo {         // CHECK: class Bar
 };
 
 int main() {
   Foo *Pointer = 0; // CHECK: Bar *Pointer = 0;
   return 0;
 }
 
-// RUN: clang-rename rename-all -old-name=Foo -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename  -qualified-name=Foo -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s

test/clang-refactor/rename/InvalidNewName.cpp

+// RUN: not clang-refactor rename -new-name=class -offset=133 %s 2>&1 | FileCheck %s
+// CHECK: ERROR: new name is not a valid identifier in C++17.

test/clang-refactor/rename/MemberExprMacro.cpp

 class Baz {
 public:
   int Foo;  /* Test 1 */    // CHECK: int Bar;
 };
 
 int qux(int x) { return 0; }
 #define MACRO(a) qux(a)
 
 int main() {
   Baz baz;
   baz.Foo = 1; /* Test 2 */ // CHECK: baz.Bar = 1;
   MACRO(baz.Foo);           // CHECK: MACRO(baz.Bar);
   int y = baz.Foo;          // CHECK: int y = baz.Bar;
 }
 
 // Test 1.
-// RUN: clang-rename -offset=26 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=26 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=155 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=155 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'Foo.*' <file>

test/clang-refactor/rename/Namespace.cpp

 namespace gcc /* Test 1 */ {  // CHECK: namespace clang /* Test 1 */ {
   int x;
 }
 
 void boo() {
   gcc::x = 42;                // CHECK: clang::x = 42;
 }
 
 // Test 1.
-// RUN: clang-rename -offset=10 -new-name=clang %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=10 -new-name=clang %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'Foo.*' <file>

test/clang-refactor/rename/NoNewName.cpp

+// Check for an error while -new-name argument has not been passed to
+// clang-refactor rename.
+// RUN: not clang-refactor rename -offset=133 %s 2>&1 | FileCheck %s
+// CHECK: clang-refactor rename: -new-name or -input is required.

test/clang-refactor/rename/QualifiedNameNotFound.cpp

+// RUN: not clang-refactor rename  -new-name=Foo -qualified-name=Bar %s -- 2>&1 | FileCheck %s
+// CHECK: USREngine: could not find symbol Bar.

test/clang-refactor/rename/TemplateClassInstantiation.cpp

int main() {
   Foo<bool> b;              // CHECK: Bar<bool> b;
   b.member = false;
   Foo<bool>::foo(false);    // CHECK: Bar<bool>::foo(false);
 
   return 0;
 }
 
 // Test 1.
-// RUN: clang-rename -offset=29 -new-name=Bar %s -- -fno-delayed-template-parsing | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=29 -new-name=Bar %s -- -fno-delayed-template-parsing | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=324 -new-name=Bar %s -- -fno-delayed-template-parsing | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=324 -new-name=Bar %s -- -fno-delayed-template-parsing | sed 's,//.*,,' | FileCheck %s
 // Test 3.
-// RUN: clang-rename -offset=463 -new-name=Bar %s -- -fno-delayed-template-parsing | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=463 -new-name=Bar %s -- -fno-delayed-template-parsing | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'Foo.*' <file>

test/clang-refactor/rename/TemplateTypename.cpp

 template <typename T /* Test 1 */>              // CHECK: template <typename U /* Test 1 */>
 class Foo {
 T foo(T arg, T& ref, T* /* Test 2 */ ptr) {     // CHECK: U foo(U arg, U& ref, U* /* Test 2 */ ptr) {
   T value;                                      // CHECK: U value;
   int number = 42;
   value = (T)number;                            // CHECK: value = (U)number;
   value = static_cast<T /* Test 3 */>(number);  // CHECK: value = static_cast<U /* Test 3 */>(number);
   return value;
 }
 
 static void foo(T value) {}                     // CHECK: static void foo(U value) {}
 
 T member;                                       // CHECK: U member;
 };
 
 // Test 1.
-// RUN: clang-rename -offset=19 -new-name=U %s -- -fno-delayed-template-parsing | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=19 -new-name=U %s -- -fno-delayed-template-parsing | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=126 -new-name=U %s -- -fno-delayed-template-parsing | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=126 -new-name=U %s -- -fno-delayed-template-parsing | sed 's,//.*,,' | FileCheck %s
 // Test 3.
-// RUN: clang-rename -offset=392 -new-name=U %s -- -fno-delayed-template-parsing | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=392 -new-name=U %s -- -fno-delayed-template-parsing | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'T.*' <file>

test/clang-refactor/rename/UserDefinedConversion.cpp

 
 int main() {
   Baz boo;
   Foo foo = static_cast<Foo>(boo);      // CHECK: Bar foo = static_cast<Bar>(boo);
   return 0;
 }
 
 // Test 1.
-// RUN: clang-rename -offset=7 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=7 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=164 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=164 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'Foo.*' <file>

test/clang-refactor/rename/Variable.cpp

Baz = Foo;                          // CHECK: Baz = Foo;
     Baz = Foo;                        // CHECK: Baz = Foo;
     Foo = A::Foo /* Test 3 */ + Baz;  // CHECK: Foo = A::Bar /* Test 3 */ + Baz;
     A::Foo /* Test 4 */ = b.Foo;      // CHECK: A::Bar /* Test 4 */ = b.Foo;
   }
   Foo = b.Foo;                        // Foo = b.Foo;
 }
 
 // Test 1.
-// RUN: clang-rename -offset=18 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=18 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=206 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=206 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 3.
-// RUN: clang-rename -offset=613 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=613 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 4.
-// RUN: clang-rename -offset=688 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=688 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'Foo.*' <file>

test/clang-refactor/rename/VariableMacro.cpp

 #define Baz Foo // CHECK: #define Baz Bar
 
 void foo(int value) {}
 
 void macro() {
   int Foo;  /* Test 1 */  // CHECK: int Bar;
   Foo = 42; /* Test 2 */  // CHECK: Bar = 42;
   Baz -= 0;
   foo(Foo); /* Test 3 */  // CHECK: foo(Bar);
   foo(Baz);
 }
 
 // Test 1.
-// RUN: clang-rename -offset=88 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=88 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 2.
-// RUN: clang-rename -offset=129 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=129 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 // Test 3.
-// RUN: clang-rename -offset=191 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// RUN: clang-refactor rename -offset=191 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
 
 // To find offsets after modifying the file, use:
 //   grep -Ubo 'Foo.*' <file>

test/clang-rename/ClassTestMultiByName.cpp

-class Foo1 { // CHECK: class Bar1
-};
-
-class Foo2 { // CHECK: class Bar2
-};
-
-// Test 1.
-// RUN: clang-rename rename-all -old-name=Foo1 -new-name=Bar1 -old-name=Foo2 -new-name=Bar2 %s -- | sed 's,//.*,,' | FileCheck %s

test/clang-rename/ClassTestMultiByNameYAML.cpp

-class Foo1 { // CHECK: class Bar1
-};
-
-class Foo2 { // CHECK: class Bar2
-};
-
-// Test 1.
-// RUN: clang-rename rename-all -input %S/Inputs/ClassTestMultiByNameYAMLRenameAll.yaml %s -- | sed 's,//.*,,' | FileCheck %s
-// Test 2.
-// RUN: clang-rename rename-all -input %S/Inputs/ClassTestMultiByNameYAMLRenameAt.yaml %s -- | sed 's,//.*,,' | FileCheck %s

test/clang-rename/InvalidNewName.cpp

-// RUN: not clang-rename -new-name=class -offset=133 %s 2>&1 | FileCheck %s
-// CHECK: ERROR: new name is not a valid identifier in C++17.

test/clang-rename/InvalidOldName.cpp

-// RUN: not clang-rename rename-all -new-name=Foo -old-name=Bar %s -- 2>&1 | FileCheck %s
-// CHECK: clang-rename: could not find symbol Bar.

test/clang-rename/NoNewName.cpp

-// Check for an error while -new-name argument has not been passed to
-// clang-rename.
-// RUN: not clang-rename -offset=133 %s 2>&1 | FileCheck %s
-// CHECK: clang-rename: for the -new-name option: must be specified

unittests/CMakeLists.txt

 add_custom_target(ExtraToolsUnitTests)
 set_target_properties(ExtraToolsUnitTests PROPERTIES FOLDER "Extra Tools Unit Tests")
 
 function(add_extra_unittest test_dirname)
   add_unittest(ExtraToolsUnitTests ${test_dirname} ${ARGN})
 endfunction()
 
 add_subdirectory(clang-apply-replacements)
-add_subdirectory(clang-rename)
 add_subdirectory(clang-query)
 add_subdirectory(clang-tidy)
 add_subdirectory(include-fixer)

unittests/clang-rename/CMakeLists.txt

-set(LLVM_LINK_COMPONENTS
-  support
-  )
-
-get_filename_component(CLANG_RENAME_SOURCE_DIR
-  ${CMAKE_CURRENT_SOURCE_DIR}/../../clang-rename REALPATH)
-include_directories(
-  ${CLANG_RENAME_SOURCE_DIR}
-  )
-
-add_extra_unittest(ClangRenameTests
-  USRLocFindingTest.cpp
-  ${CLANG_RENAME_SOURCE_DIR}/USRFinder.cpp
-  ${CLANG_RENAME_SOURCE_DIR}/USRFindingAction.cpp
-  )
-
-target_link_libraries(ClangRenameTests
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangFrontend
-  clangIndex
-  clangLex
-  clangTooling
-  )

unittests/clang-rename/USRLocFindingTest.cpp

-#include "USRFindingAction.h"
-#include "clang/Tooling/Tooling.h"
-#include "gtest/gtest.h"
-#include <map>
-#include <set>
-#include <vector>
-
-namespace clang {
-namespace rename {
-namespace test {
-
-// Determines if the symbol group invariants hold. To recap, those invariants
-// are:
-//  (1) All symbols in the same symbol group share the same USR.
-//  (2) Two symbols from two different groups do not share the same USR.
-static void testOffsetGroups(const char *Code,
-                             const std::vector<std::vector<unsigned>> Groups) {
-  std::set<std::string> AllUSRs, CurrUSR;
-
-  for (const auto &Group : Groups) {
-    // Groups the invariants do not hold then the value of USR is also invalid,
-    // but at that point the test has already failed and USR ceases to be
-    // useful.
-    std::string USR;
-    for (const auto &Offset : Group) {
-      USRFindingAction Action(Offset, std::string());
-      auto Factory = tooling::newFrontendActionFactory(&Action);
-      EXPECT_TRUE(tooling::runToolOnCode(Factory->create(), Code));
-      const auto &USRs = Action.getUSRs();
-      EXPECT_EQ(1u, USRs.size());
-      USR = USRs[0];
-      CurrUSR.insert(USR);
-    }
-    EXPECT_EQ(1u, CurrUSR.size());
-    CurrUSR.clear();
-    AllUSRs.insert(USR);
-  }
-
-  EXPECT_EQ(Groups.size(), AllUSRs.size());
-}
-
-
-TEST(USRLocFinding, FindsVarUSR) {
-  const char VarTest[] = "\n\
-namespace A {\n\
-int foo;\n\
-}\n\
-int foo;\n\
-int bar = foo;\n\
-int baz = A::foo;\n\
-void fun1() {\n\
-  struct {\n\
-    int foo;\n\
-  } b = { 100 };\n\
-  int foo = 100;\n\
-  baz = foo;\n\
-  {\n\
-    extern int foo;\n\
-    baz = foo;\n\
-    foo = A::foo + baz;\n\
-    A::foo = b.foo;\n\
-  }\n\
- foo = b.foo;\n\
-}\n";
-  std::vector<std::vector<unsigned>> VarTestOffsets(3);
-  VarTestOffsets[0].push_back(19);
-  VarTestOffsets[0].push_back(63);
-  VarTestOffsets[0].push_back(205);
-  VarTestOffsets[0].push_back(223);
-  VarTestOffsets[1].push_back(30);
-  VarTestOffsets[1].push_back(45);
-  VarTestOffsets[1].push_back(172);
-  VarTestOffsets[1].push_back(187);
-  VarTestOffsets[2].push_back(129);
-  VarTestOffsets[2].push_back(148);
-  VarTestOffsets[2].push_back(242);
-
-  testOffsetGroups(VarTest, VarTestOffsets);
-}
-
-} // namespace test
-} // namespace rename
-} // namespace clang