| 1 |
//===--- RenamingAction.cpp - Clang refactoring library -------------------===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
/// |
| 9 |
/// \file |
| 10 |
/// Provides an action to rename every symbol at a point. |
| 11 |
/// |
| 12 |
//===----------------------------------------------------------------------===// |
| 13 |
|
| 14 |
#include "clang/Tooling/Refactoring/Rename/RenamingAction.h" |
| 15 |
#include "clang/AST/ASTConsumer.h" |
| 16 |
#include "clang/AST/ASTContext.h" |
| 17 |
#include "clang/Basic/FileManager.h" |
| 18 |
#include "clang/Frontend/CompilerInstance.h" |
| 19 |
#include "clang/Frontend/FrontendAction.h" |
| 20 |
#include "clang/Lex/Lexer.h" |
| 21 |
#include "clang/Lex/Preprocessor.h" |
| 22 |
#include "clang/Tooling/CommonOptionsParser.h" |
| 23 |
#include "clang/Tooling/Refactoring.h" |
| 24 |
#include "clang/Tooling/Refactoring/RefactoringAction.h" |
| 25 |
#include "clang/Tooling/Refactoring/RefactoringDiagnostic.h" |
| 26 |
#include "clang/Tooling/Refactoring/RefactoringOptions.h" |
| 27 |
#include "clang/Tooling/Refactoring/Rename/SymbolName.h" |
| 28 |
#include "clang/Tooling/Refactoring/Rename/USRFinder.h" |
| 29 |
#include "clang/Tooling/Refactoring/Rename/USRFindingAction.h" |
| 30 |
#include "clang/Tooling/Refactoring/Rename/USRLocFinder.h" |
| 31 |
#include "clang/Tooling/Tooling.h" |
| 32 |
#include "llvm/ADT/STLExtras.h" |
| 33 |
#include "llvm/Support/Errc.h" |
| 34 |
#include "llvm/Support/Error.h" |
| 35 |
#include <string> |
| 36 |
#include <vector> |
| 37 |
|
| 38 |
using namespace llvm; |
| 39 |
|
| 40 |
namespace clang { |
| 41 |
namespace tooling { |
| 42 |
|
| 43 |
namespace { |
| 44 |
|
| 45 |
Expected<SymbolOccurrences> |
| 46 |
findSymbolOccurrences(const NamedDecl *ND, RefactoringRuleContext &Context) { |
| 47 |
std::vector<std::string> USRs = |
| 48 |
getUSRsForDeclaration(ND, Context.getASTContext()); |
| 49 |
std::string PrevName = ND->getNameAsString(); |
| 50 |
return getOccurrencesOfUSRs(USRs, PrevName, |
| 51 |
Context.getASTContext().getTranslationUnitDecl()); |
| 52 |
} |
| 53 |
|
| 54 |
} // end anonymous namespace |
| 55 |
|
| 56 |
const RefactoringDescriptor &RenameOccurrences::describe() { |
| 57 |
static const RefactoringDescriptor Descriptor = { |
| 58 |
"local-rename", |
| 59 |
"Rename", |
| 60 |
"Finds and renames symbols in code with no indexer support", |
| 61 |
}; |
| 62 |
return Descriptor; |
| 63 |
} |
| 64 |
|
| 65 |
Expected<RenameOccurrences> |
| 66 |
RenameOccurrences::initiate(RefactoringRuleContext &Context, |
| 67 |
SourceRange SelectionRange, std::string NewName) { |
| 68 |
const NamedDecl *ND = |
| 69 |
getNamedDeclAt(Context.getASTContext(), SelectionRange.getBegin()); |
| 70 |
if (!ND) |
| 71 |
return Context.createDiagnosticError( |
| 72 |
SelectionRange.getBegin(), diag::err_refactor_selection_no_symbol); |
| 73 |
return RenameOccurrences(getCanonicalSymbolDeclaration(ND), |
| 74 |
std::move(NewName)); |
| 75 |
} |
| 76 |
|
| 77 |
const NamedDecl *RenameOccurrences::getRenameDecl() const { return ND; } |
| 78 |
|
| 79 |
Expected<AtomicChanges> |
| 80 |
RenameOccurrences::createSourceReplacements(RefactoringRuleContext &Context) { |
| 81 |
Expected<SymbolOccurrences> Occurrences = findSymbolOccurrences(ND, Context); |
| 82 |
if (!Occurrences) |
| 83 |
return Occurrences.takeError(); |
| 84 |
// FIXME: Verify that the new name is valid. |
| 85 |
SymbolName Name(NewName); |
| 86 |
return createRenameReplacements( |
| 87 |
*Occurrences, Context.getASTContext().getSourceManager(), Name); |
| 88 |
} |
| 89 |
|
| 90 |
Expected<QualifiedRenameRule> |
| 91 |
QualifiedRenameRule::initiate(RefactoringRuleContext &Context, |
| 92 |
std::string OldQualifiedName, |
| 93 |
std::string NewQualifiedName) { |
| 94 |
const NamedDecl *ND = |
| 95 |
getNamedDeclFor(Context.getASTContext(), OldQualifiedName); |
| 96 |
if (!ND) |
| 97 |
return llvm::make_error<llvm::StringError>("Could not find symbol " + |
| 98 |
OldQualifiedName, |
| 99 |
llvm::errc::invalid_argument); |
| 100 |
return QualifiedRenameRule(ND, std::move(NewQualifiedName)); |
| 101 |
} |
| 102 |
|
| 103 |
const RefactoringDescriptor &QualifiedRenameRule::describe() { |
| 104 |
static const RefactoringDescriptor Descriptor = { |
| 105 |
/*Name=*/"local-qualified-rename", |
| 106 |
/*Title=*/"Qualified Rename", |
| 107 |
/*Description=*/ |
| 108 |
R"(Finds and renames qualified symbols in code within a translation unit. |
| 109 |
It is used to move/rename a symbol to a new namespace/name: |
| 110 |
* Supported symbols: classes, class members, functions, enums, and type alias. |
| 111 |
* Renames all symbol occurrences from the old qualified name to the new |
| 112 |
qualified name. All symbol references will be correctly qualified; For |
| 113 |
symbol definitions, only name will be changed. |
| 114 |
For example, rename "A::Foo" to "B::Bar": |
| 115 |
Old code: |
| 116 |
namespace foo { |
| 117 |
class A {}; |
| 118 |
} |
| 119 |
|
| 120 |
namespace bar { |
| 121 |
void f(foo::A a) {} |
| 122 |
} |
| 123 |
|
| 124 |
New code after rename: |
| 125 |
namespace foo { |
| 126 |
class B {}; |
| 127 |
} |
| 128 |
|
| 129 |
namespace bar { |
| 130 |
void f(B b) {} |
| 131 |
})" |
| 132 |
}; |
| 133 |
return Descriptor; |
| 134 |
} |
| 135 |
|
| 136 |
Expected<AtomicChanges> |
| 137 |
QualifiedRenameRule::createSourceReplacements(RefactoringRuleContext &Context) { |
| 138 |
auto USRs = getUSRsForDeclaration(ND, Context.getASTContext()); |
| 139 |
assert(!USRs.empty()); |
| 140 |
return tooling::createRenameAtomicChanges( |
| 141 |
USRs, NewQualifiedName, Context.getASTContext().getTranslationUnitDecl()); |
| 142 |
} |
| 143 |
|
| 144 |
Expected<std::vector<AtomicChange>> |
| 145 |
createRenameReplacements(const SymbolOccurrences &Occurrences, |
| 146 |
const SourceManager &SM, const SymbolName &NewName) { |
| 147 |
// FIXME: A true local rename can use just one AtomicChange. |
| 148 |
std::vector<AtomicChange> Changes; |
| 149 |
for (const auto &Occurrence : Occurrences) { |
| 150 |
ArrayRef<SourceRange> Ranges = Occurrence.getNameRanges(); |
| 151 |
assert(NewName.getNamePieces().size() == Ranges.size() && |
| 152 |
"Mismatching number of ranges and name pieces"); |
| 153 |
AtomicChange Change(SM, Ranges[0].getBegin()); |
| 154 |
for (const auto &Range : llvm::enumerate(Ranges)) { |
| 155 |
auto Error = |
| 156 |
Change.replace(SM, CharSourceRange::getCharRange(Range.value()), |
| 157 |
NewName.getNamePieces()[Range.index()]); |
| 158 |
if (Error) |
| 159 |
return std::move(Error); |
| 160 |
} |
| 161 |
Changes.push_back(std::move(Change)); |
| 162 |
} |
| 163 |
return std::move(Changes); |
| 164 |
} |
| 165 |
|
| 166 |
/// Takes each atomic change and inserts its replacements into the set of |
| 167 |
/// replacements that belong to the appropriate file. |
| 168 |
static void convertChangesToFileReplacements( |
| 169 |
ArrayRef<AtomicChange> AtomicChanges, |
| 170 |
std::map<std::string, tooling::Replacements> *FileToReplaces) { |
| 171 |
for (const auto &AtomicChange : AtomicChanges) { |
| 172 |
for (const auto &Replace : AtomicChange.getReplacements()) { |
| 173 |
llvm::Error Err = |
| 174 |
(*FileToReplaces)[std::string(Replace.getFilePath())].add(Replace); |
| 175 |
if (Err) { |
| 176 |
llvm::errs() << "Renaming failed in " << Replace.getFilePath() << "! " |
| 177 |
<< llvm::toString(std::move(Err)) << "\n"; |
| 178 |
} |
| 179 |
} |
| 180 |
} |
| 181 |
} |
| 182 |
|
| 183 |
class RenamingASTConsumer : public ASTConsumer { |
| 184 |
public: |
| 185 |
RenamingASTConsumer( |
| 186 |
const std::vector<std::string> &NewNames, |
| 187 |
const std::vector<std::string> &PrevNames, |
| 188 |
const std::vector<std::vector<std::string>> &USRList, |
| 189 |
std::map<std::string, tooling::Replacements> &FileToReplaces, |
| 190 |
bool PrintLocations) |
| 191 |
: NewNames(NewNames), PrevNames(PrevNames), USRList(USRList), |
| 192 |
FileToReplaces(FileToReplaces), PrintLocations(PrintLocations) {} |
| 193 |
|
| 194 |
void HandleTranslationUnit(ASTContext &Context) override { |
| 195 |
for (unsigned I = 0; I < NewNames.size(); ++I) { |
| 196 |
// If the previous name was not found, ignore this rename request. |
| 197 |
if (PrevNames[I].empty()) |
| 198 |
continue; |
| 199 |
|
| 200 |
HandleOneRename(Context, NewNames[I], PrevNames[I], USRList[I]); |
| 201 |
} |
| 202 |
} |
| 203 |
|
| 204 |
void HandleOneRename(ASTContext &Context, const std::string &NewName, |
| 205 |
const std::string &PrevName, |
| 206 |
const std::vector<std::string> &USRs) { |
| 207 |
const SourceManager &SourceMgr = Context.getSourceManager(); |
| 208 |
|
| 209 |
SymbolOccurrences Occurrences = tooling::getOccurrencesOfUSRs( |
| 210 |
USRs, PrevName, Context.getTranslationUnitDecl()); |
| 211 |
if (PrintLocations) { |
| 212 |
for (const auto &Occurrence : Occurrences) { |
| 213 |
FullSourceLoc FullLoc(Occurrence.getNameRanges()[0].getBegin(), |
| 214 |
SourceMgr); |
| 215 |
errs() << "clang-rename: renamed at: " << SourceMgr.getFilename(FullLoc) |
| 216 |
<< ":" << FullLoc.getSpellingLineNumber() << ":" |
| 217 |
<< FullLoc.getSpellingColumnNumber() << "\n"; |
| 218 |
} |
| 219 |
} |
| 220 |
// FIXME: Support multi-piece names. |
| 221 |
// FIXME: better error handling (propagate error out). |
| 222 |
SymbolName NewNameRef(NewName); |
| 223 |
Expected<std::vector<AtomicChange>> Change = |
| 224 |
createRenameReplacements(Occurrences, SourceMgr, NewNameRef); |
| 225 |
if (!Change) { |
| 226 |
llvm::errs() << "Failed to create renaming replacements for '" << PrevName |
| 227 |
<< "'! " << llvm::toString(Change.takeError()) << "\n"; |
| 228 |
return; |
| 229 |
} |
| 230 |
convertChangesToFileReplacements(*Change, &FileToReplaces); |
| 231 |
} |
| 232 |
|
| 233 |
private: |
| 234 |
const std::vector<std::string> &NewNames, &PrevNames; |
| 235 |
const std::vector<std::vector<std::string>> &USRList; |
| 236 |
std::map<std::string, tooling::Replacements> &FileToReplaces; |
| 237 |
bool PrintLocations; |
| 238 |
}; |
| 239 |
|
| 240 |
// A renamer to rename symbols which are identified by a give USRList to |
| 241 |
// new name. |
| 242 |
// |
| 243 |
// FIXME: Merge with the above RenamingASTConsumer. |
| 244 |
class USRSymbolRenamer : public ASTConsumer { |
| 245 |
public: |
| 246 |
USRSymbolRenamer(const std::vector<std::string> &NewNames, |
| 247 |
const std::vector<std::vector<std::string>> &USRList, |
| 248 |
std::map<std::string, tooling::Replacements> &FileToReplaces) |
| 249 |
: NewNames(NewNames), USRList(USRList), FileToReplaces(FileToReplaces) { |
| 250 |
assert(USRList.size() == NewNames.size()); |
| 251 |
} |
| 252 |
|
| 253 |
void HandleTranslationUnit(ASTContext &Context) override { |
| 254 |
for (unsigned I = 0; I < NewNames.size(); ++I) { |
| 255 |
// FIXME: Apply AtomicChanges directly once the refactoring APIs are |
| 256 |
// ready. |
| 257 |
auto AtomicChanges = tooling::createRenameAtomicChanges( |
| 258 |
USRList[I], NewNames[I], Context.getTranslationUnitDecl()); |
| 259 |
convertChangesToFileReplacements(AtomicChanges, &FileToReplaces); |
| 260 |
} |
| 261 |
} |
| 262 |
|
| 263 |
private: |
| 264 |
const std::vector<std::string> &NewNames; |
| 265 |
const std::vector<std::vector<std::string>> &USRList; |
| 266 |
std::map<std::string, tooling::Replacements> &FileToReplaces; |
| 267 |
}; |
| 268 |
|
| 269 |
std::unique_ptr<ASTConsumer> RenamingAction::newASTConsumer() { |
| 270 |
return std::make_unique<RenamingASTConsumer>(NewNames, PrevNames, USRList, |
| 271 |
FileToReplaces, PrintLocations); |
| 272 |
} |
| 273 |
|
| 274 |
std::unique_ptr<ASTConsumer> QualifiedRenamingAction::newASTConsumer() { |
| 275 |
return std::make_unique<USRSymbolRenamer>(NewNames, USRList, FileToReplaces); |
| 276 |
} |
| 277 |
|
| 278 |
} // end namespace tooling |
| 279 |
} // end namespace clang |