//===--- USRLocFinder.cpp - Clang refactoring library ---------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
///
/// \file
/// Methods for finding all instances of a USR. Our strategy is very
/// simple; we just compare the USR at every relevant AST node with the one
/// provided.
///
//===----------------------------------------------------------------------===//
#include "clang/Tooling/Refactoring/Rename/USRLocFinder.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/ParentMapContext.h"
#include "clang/AST/RecursiveASTVisitor.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Lex/Lexer.h"
#include "clang/Tooling/Refactoring/Lookup.h"
#include "clang/Tooling/Refactoring/RecursiveSymbolVisitor.h"
#include "clang/Tooling/Refactoring/Rename/SymbolName.h"
#include "clang/Tooling/Refactoring/Rename/USRFinder.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Casting.h"
#include <cstddef>
#include <set>
#include <string>
#include <vector>
using namespace llvm;
namespace clang {
namespace tooling {
namespace {
// Returns true if the given Loc is valid for edit. We don't edit the
// SourceLocations that are valid or in temporary buffer.
bool IsValidEditLoc(const clang::SourceManager& SM, clang::SourceLocation Loc) {
if (Loc.isInvalid())
return false;
const clang::FullSourceLoc FullLoc(Loc, SM);
std::pair<clang::FileID, unsigned> FileIdAndOffset =
FullLoc.getSpellingLoc().getDecomposedLoc();
return SM.getFileEntryForID(FileIdAndOffset.first) != nullptr;
}
// This visitor recursively searches for all instances of a USR in a
// translation unit and stores them for later usage.
class USRLocFindingASTVisitor
: public RecursiveSymbolVisitor<USRLocFindingASTVisitor> {
public:
explicit USRLocFindingASTVisitor(const std::vector<std::string> &USRs,
StringRef PrevName,
const ASTContext &Context)
: RecursiveSymbolVisitor(Context.getSourceManager(),
Context.getLangOpts()),
USRSet(USRs.begin(), USRs.end()), PrevName(PrevName), Context(Context) {
}
bool visitSymbolOccurrence(const NamedDecl *ND,
ArrayRef<SourceRange> NameRanges) {
if (USRSet.find(getUSRForDecl(ND)) != USRSet.end()) {
assert(NameRanges.size() == 1 &&
"Multiple name pieces are not supported yet!");
SourceLocation Loc = NameRanges[0].getBegin();
const SourceManager &SM = Context.getSourceManager();
// TODO: Deal with macro occurrences correctly.
if (Loc.isMacroID())
Loc = SM.getSpellingLoc(Loc);
checkAndAddLocation(Loc);
}
return true;
}
// Non-visitors:
/// Returns a set of unique symbol occurrences. Duplicate or
/// overlapping occurrences are erroneous and should be reported!
SymbolOccurrences takeOccurrences() { return std::move(Occurrences); }
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.getNamePieces()[0]);
// The token of the source location we find actually has the old
// name.
if (Offset != StringRef::npos)
Occurrences.emplace_back(PrevName, SymbolOccurrence::MatchingSymbol,
BeginLoc.getLocWithOffset(Offset));
}
const std::set<std::string> USRSet;
const SymbolName PrevName;
SymbolOccurrences Occurrences;
const ASTContext &Context;
};
SourceLocation StartLocationForType(TypeLoc TL) {
// For elaborated types (e.g. `struct a::A`) we want the portion after the
// `struct` but including the namespace qualifier, `a::`.
if (auto ElaboratedTypeLoc = TL.getAs<clang::ElaboratedTypeLoc>()) {
NestedNameSpecifierLoc NestedNameSpecifier =
ElaboratedTypeLoc.getQualifierLoc();
if (NestedNameSpecifier.getNestedNameSpecifier())
return NestedNameSpecifier.getBeginLoc();
TL = TL.getNextTypeLoc();
}
return TL.getBeginLoc();
}
SourceLocation EndLocationForType(TypeLoc TL) {
// Dig past any namespace or keyword qualifications.
while (TL.getTypeLocClass() == TypeLoc::Elaborated ||
TL.getTypeLocClass() == TypeLoc::Qualified)
TL = TL.getNextTypeLoc();
// The location for template specializations (e.g. Foo<int>) includes the
// templated types in its location range. We want to restrict this to just
// before the `<` character.
if (TL.getTypeLocClass() == TypeLoc::TemplateSpecialization) {
return TL.castAs<TemplateSpecializationTypeLoc>()
.getLAngleLoc()
.getLocWithOffset(-1);
}
return TL.getEndLoc();
}
NestedNameSpecifier *GetNestedNameForType(TypeLoc TL) {
// Dig past any keyword qualifications.
while (TL.getTypeLocClass() == TypeLoc::Qualified)
TL = TL.getNextTypeLoc();
// For elaborated types (e.g. `struct a::A`) we want the portion after the
// `struct` but including the namespace qualifier, `a::`.
if (auto ElaboratedTypeLoc = TL.getAs<clang::ElaboratedTypeLoc>())
return ElaboratedTypeLoc.getQualifierLoc().getNestedNameSpecifier();
return nullptr;
}
// Find all locations identified by the given USRs for rename.
//
// This class will traverse the AST and find every AST node whose USR is in the
// given USRs' set.
class RenameLocFinder : public RecursiveASTVisitor<RenameLocFinder> {
public:
RenameLocFinder(llvm::ArrayRef<std::string> USRs, ASTContext &Context)
: USRSet(USRs.begin(), USRs.end()), Context(Context) {}
// A structure records all information of a symbol reference being renamed.
// We try to add as few prefix qualifiers as possible.
struct RenameInfo {
// The begin location of a symbol being renamed.
SourceLocation Begin;
// The end location of a symbol being renamed.
SourceLocation End;
// The declaration of a symbol being renamed (can be nullptr).
const NamedDecl *FromDecl;
// The declaration in which the nested name is contained (can be nullptr).
const Decl *Context;
// The nested name being replaced (can be nullptr).
const NestedNameSpecifier *Specifier;
// Determine whether the prefix qualifiers of the NewName should be ignored.
// Normally, we set it to true for the symbol declaration and definition to
// avoid adding prefix qualifiers.
// For example, if it is true and NewName is "a::b::foo", then the symbol
// occurrence which the RenameInfo points to will be renamed to "foo".
bool IgnorePrefixQualifers;
};
bool VisitNamedDecl(const NamedDecl *Decl) {
// UsingDecl has been handled in other place.
if (llvm::isa<UsingDecl>(Decl))
return true;
// DestructorDecl has been handled in Typeloc.
if (llvm::isa<CXXDestructorDecl>(Decl))
return true;
if (Decl->isImplicit())
return true;
if (isInUSRSet(Decl)) {
// For the case of renaming an alias template, we actually rename the
// underlying alias declaration of the template.
if (const auto* TAT = dyn_cast<TypeAliasTemplateDecl>(Decl))
Decl = TAT->getTemplatedDecl();
auto StartLoc = Decl->getLocation();
auto EndLoc = StartLoc;
if (IsValidEditLoc(Context.getSourceManager(), StartLoc)) {
RenameInfo Info = {StartLoc,
EndLoc,
/*FromDecl=*/nullptr,
/*Context=*/nullptr,
/*Specifier=*/nullptr,
/*IgnorePrefixQualifers=*/true};
RenameInfos.push_back(Info);
}
}
return true;
}
bool VisitMemberExpr(const MemberExpr *Expr) {
const NamedDecl *Decl = Expr->getFoundDecl();
auto StartLoc = Expr->getMemberLoc();
auto EndLoc = Expr->getMemberLoc();
if (isInUSRSet(Decl)) {
RenameInfos.push_back({StartLoc, EndLoc,
/*FromDecl=*/nullptr,
/*Context=*/nullptr,
/*Specifier=*/nullptr,
/*IgnorePrefixQualifiers=*/true});
}
return true;
}
bool VisitCXXConstructorDecl(const CXXConstructorDecl *CD) {
// Fix the constructor initializer when renaming class members.
for (const auto *Initializer : CD->inits()) {
// Ignore implicit initializers.
if (!Initializer->isWritten())
continue;
if (const FieldDecl *FD = Initializer->getMember()) {
if (isInUSRSet(FD)) {
auto Loc = Initializer->getSourceLocation();
RenameInfos.push_back({Loc, Loc,
/*FromDecl=*/nullptr,
/*Context=*/nullptr,
/*Specifier=*/nullptr,
/*IgnorePrefixQualifiers=*/true});
}
}
}
return true;
}
bool VisitDeclRefExpr(const DeclRefExpr *Expr) {
const NamedDecl *Decl = Expr->getFoundDecl();
// Get the underlying declaration of the shadow declaration introduced by a
// using declaration.
if (auto *UsingShadow = llvm::dyn_cast<UsingShadowDecl>(Decl)) {
Decl = UsingShadow->getTargetDecl();
}
auto StartLoc = Expr->getBeginLoc();
// For template function call expressions like `foo<int>()`, we want to
// restrict the end of location to just before the `<` character.
SourceLocation EndLoc = Expr->hasExplicitTemplateArgs()
? Expr->getLAngleLoc().getLocWithOffset(-1)
: Expr->getEndLoc();
if (const auto *MD = llvm::dyn_cast<CXXMethodDecl>(Decl)) {
if (isInUSRSet(MD)) {
// Handle renaming static template class methods, we only rename the
// name without prefix qualifiers and restrict the source range to the
// name.
RenameInfos.push_back({EndLoc, EndLoc,
/*FromDecl=*/nullptr,
/*Context=*/nullptr,
/*Specifier=*/nullptr,
/*IgnorePrefixQualifiers=*/true});
return true;
}
}
// In case of renaming an enum declaration, we have to explicitly handle
// unscoped enum constants referenced in expressions (e.g.
// "auto r = ns1::ns2::Green" where Green is an enum constant of an unscoped
// enum decl "ns1::ns2::Color") as these enum constants cannot be caught by
// TypeLoc.
if (const auto *T = llvm::dyn_cast<EnumConstantDecl>(Decl)) {
// FIXME: Handle the enum constant without prefix qualifiers (`a = Green`)
// when renaming an unscoped enum declaration with a new namespace.
if (!Expr->hasQualifier())
return true;
if (const auto *ED =
llvm::dyn_cast_or_null<EnumDecl>(getClosestAncestorDecl(*T))) {
if (ED->isScoped())
return true;
Decl = ED;
}
// The current fix would qualify "ns1::ns2::Green" as
// "ns1::ns2::Color::Green".
//
// Get the EndLoc of the replacement by moving 1 character backward (
// to exclude the last '::').
//
// ns1::ns2::Green;
// ^ ^^
// BeginLoc |EndLoc of the qualifier
// new EndLoc
EndLoc = Expr->getQualifierLoc().getEndLoc().getLocWithOffset(-1);
assert(EndLoc.isValid() &&
"The enum constant should have prefix qualifers.");
}
if (isInUSRSet(Decl) &&
IsValidEditLoc(Context.getSourceManager(), StartLoc)) {
RenameInfo Info = {StartLoc,
EndLoc,
Decl,
getClosestAncestorDecl(*Expr),
Expr->getQualifier(),
/*IgnorePrefixQualifers=*/false};
RenameInfos.push_back(Info);
}
return true;
}
bool VisitUsingDecl(const UsingDecl *Using) {
for (const auto *UsingShadow : Using->shadows()) {
if (isInUSRSet(UsingShadow->getTargetDecl())) {
UsingDecls.push_back(Using);
break;
}
}
return true;
}
bool VisitNestedNameSpecifierLocations(NestedNameSpecifierLoc NestedLoc) {
if (!NestedLoc.getNestedNameSpecifier()->getAsType())
return true;
if (const auto *TargetDecl =
getSupportedDeclFromTypeLoc(NestedLoc.getTypeLoc())) {
if (isInUSRSet(TargetDecl)) {
RenameInfo Info = {NestedLoc.getBeginLoc(),
EndLocationForType(NestedLoc.getTypeLoc()),
TargetDecl,
getClosestAncestorDecl(NestedLoc),
NestedLoc.getNestedNameSpecifier()->getPrefix(),
/*IgnorePrefixQualifers=*/false};
RenameInfos.push_back(Info);
}
}
return true;
}
bool VisitTypeLoc(TypeLoc Loc) {
auto Parents = Context.getParents(Loc);
TypeLoc ParentTypeLoc;
if (!Parents.empty()) {
// Handle cases of nested name specificier locations.
//
// The VisitNestedNameSpecifierLoc interface is not impelmented in
// RecursiveASTVisitor, we have to handle it explicitly.
if (const auto *NSL = Parents[0].get<NestedNameSpecifierLoc>()) {
VisitNestedNameSpecifierLocations(*NSL);
return true;
}
if (const auto *TL = Parents[0].get<TypeLoc>())
ParentTypeLoc = *TL;
}
// Handle the outermost TypeLoc which is directly linked to the interesting
// declaration and don't handle nested name specifier locations.
if (const auto *TargetDecl = getSupportedDeclFromTypeLoc(Loc)) {
if (isInUSRSet(TargetDecl)) {
// Only handle the outermost typeLoc.
//
// For a type like "a::Foo", there will be two typeLocs for it.
// One ElaboratedType, the other is RecordType:
//
// ElaboratedType 0x33b9390 'a::Foo' sugar
// `-RecordType 0x338fef0 'class a::Foo'
// `-CXXRecord 0x338fe58 'Foo'
//
// Skip if this is an inner typeLoc.
if (!ParentTypeLoc.isNull() &&
isInUSRSet(getSupportedDeclFromTypeLoc(ParentTypeLoc)))
return true;
auto StartLoc = StartLocationForType(Loc);
auto EndLoc = EndLocationForType(Loc);
if (IsValidEditLoc(Context.getSourceManager(), StartLoc)) {
RenameInfo Info = {StartLoc,
EndLoc,
TargetDecl,
getClosestAncestorDecl(Loc),
GetNestedNameForType(Loc),
/*IgnorePrefixQualifers=*/false};
RenameInfos.push_back(Info);
}
return true;
}
}
// Handle specific template class specialiation cases.
if (const auto *TemplateSpecType =
dyn_cast<TemplateSpecializationType>(Loc.getType())) {
TypeLoc TargetLoc = Loc;
if (!ParentTypeLoc.isNull()) {
if (llvm::isa<ElaboratedType>(ParentTypeLoc.getType()))
TargetLoc = ParentTypeLoc;
}
if (isInUSRSet(TemplateSpecType->getTemplateName().getAsTemplateDecl())) {
TypeLoc TargetLoc = Loc;
// FIXME: Find a better way to handle this case.
// For the qualified template class specification type like
// "ns::Foo<int>" in "ns::Foo<int>& f();", we want the parent typeLoc
// (ElaboratedType) of the TemplateSpecializationType in order to
// catch the prefix qualifiers "ns::".
if (!ParentTypeLoc.isNull() &&
llvm::isa<ElaboratedType>(ParentTypeLoc.getType()))
TargetLoc = ParentTypeLoc;
auto StartLoc = StartLocationForType(TargetLoc);
auto EndLoc = EndLocationForType(TargetLoc);
if (IsValidEditLoc(Context.getSourceManager(), StartLoc)) {
RenameInfo Info = {
StartLoc,
EndLoc,
TemplateSpecType->getTemplateName().getAsTemplateDecl(),
getClosestAncestorDecl(DynTypedNode::create(TargetLoc)),
GetNestedNameForType(TargetLoc),
/*IgnorePrefixQualifers=*/false};
RenameInfos.push_back(Info);
}
}
}
return true;
}
// Returns a list of RenameInfo.
const std::vector<RenameInfo> &getRenameInfos() const { return RenameInfos; }
// Returns a list of using declarations which are needed to update.
const std::vector<const UsingDecl *> &getUsingDecls() const {
return UsingDecls;
}
private:
// Get the supported declaration from a given typeLoc. If the declaration type
// is not supported, returns nullptr.
const NamedDecl *getSupportedDeclFromTypeLoc(TypeLoc Loc) {
if (const auto* TT = Loc.getType()->getAs<clang::TypedefType>())
return TT->getDecl();
if (const auto *RD = Loc.getType()->getAsCXXRecordDecl())
return RD;
if (const auto *ED =
llvm::dyn_cast_or_null<EnumDecl>(Loc.getType()->getAsTagDecl()))
return ED;
return nullptr;
}
// Get the closest ancester which is a declaration of a given AST node.
template <typename ASTNodeType>
const Decl *getClosestAncestorDecl(const ASTNodeType &Node) {
auto Parents = Context.getParents(Node);
// FIXME: figure out how to handle it when there are multiple parents.
if (Parents.size() != 1)
return nullptr;
if (ASTNodeKind::getFromNodeKind<Decl>().isBaseOf(Parents[0].getNodeKind()))
return Parents[0].template get<Decl>();
return getClosestAncestorDecl(Parents[0]);
}
// Get the parent typeLoc of a given typeLoc. If there is no such parent,
// return nullptr.
const TypeLoc *getParentTypeLoc(TypeLoc Loc) const {
auto Parents = Context.getParents(Loc);
// FIXME: figure out how to handle it when there are multiple parents.
if (Parents.size() != 1)
return nullptr;
return Parents[0].get<TypeLoc>();
}
// Check whether the USR of a given Decl is in the USRSet.
bool isInUSRSet(const Decl *Decl) const {
auto USR = getUSRForDecl(Decl);
if (USR.empty())
return false;
return llvm::is_contained(USRSet, USR);
}
const std::set<std::string> USRSet;
ASTContext &Context;
std::vector<RenameInfo> RenameInfos;
// Record all interested using declarations which contains the using-shadow
// declarations of the symbol declarations being renamed.
std::vector<const UsingDecl *> UsingDecls;
};
} // namespace
SymbolOccurrences getOccurrencesOfUSRs(ArrayRef<std::string> USRs,
StringRef PrevName, Decl *Decl) {
USRLocFindingASTVisitor Visitor(USRs, PrevName, Decl->getASTContext());
Visitor.TraverseDecl(Decl);
return Visitor.takeOccurrences();
}
std::vector<tooling::AtomicChange>
createRenameAtomicChanges(llvm::ArrayRef<std::string> USRs,
llvm::StringRef NewName, Decl *TranslationUnitDecl) {
RenameLocFinder Finder(USRs, TranslationUnitDecl->getASTContext());
Finder.TraverseDecl(TranslationUnitDecl);
const SourceManager &SM =
TranslationUnitDecl->getASTContext().getSourceManager();
std::vector<tooling::AtomicChange> AtomicChanges;
auto Replace = [&](SourceLocation Start, SourceLocation End,
llvm::StringRef Text) {
tooling::AtomicChange ReplaceChange = tooling::AtomicChange(SM, Start);
llvm::Error Err = ReplaceChange.replace(
SM, CharSourceRange::getTokenRange(Start, End), Text);
if (Err) {
llvm::errs() << "Failed to add replacement to AtomicChange: "
<< llvm::toString(std::move(Err)) << "\n";
return;
}
AtomicChanges.push_back(std::move(ReplaceChange));
};
for (const auto &RenameInfo : Finder.getRenameInfos()) {
std::string ReplacedName = NewName.str();
if (RenameInfo.IgnorePrefixQualifers) {
// Get the name without prefix qualifiers from NewName.
size_t LastColonPos = NewName.find_last_of(':');
if (LastColonPos != std::string::npos)
ReplacedName = std::string(NewName.substr(LastColonPos + 1));
} else {
if (RenameInfo.FromDecl && RenameInfo.Context) {
if (!llvm::isa<clang::TranslationUnitDecl>(
RenameInfo.Context->getDeclContext())) {
ReplacedName = tooling::replaceNestedName(
RenameInfo.Specifier, RenameInfo.Begin,
RenameInfo.Context->getDeclContext(), RenameInfo.FromDecl,
NewName.startswith("::") ? NewName.str()
: ("::" + NewName).str());
} else {
// This fixes the case where type `T` is a parameter inside a function
// type (e.g. `std::function<void(T)>`) and the DeclContext of `T`
// becomes the translation unit. As a workaround, we simply use
// fully-qualified name here for all references whose `DeclContext` is
// the translation unit and ignore the possible existence of
// using-decls (in the global scope) that can shorten the replaced
// name.
llvm::StringRef ActualName = Lexer::getSourceText(
CharSourceRange::getTokenRange(
SourceRange(RenameInfo.Begin, RenameInfo.End)),
SM, TranslationUnitDecl->getASTContext().getLangOpts());
// Add the leading "::" back if the name written in the code contains
// it.
if (ActualName.startswith("::") && !NewName.startswith("::")) {
ReplacedName = "::" + NewName.str();
}
}
}
// If the NewName contains leading "::", add it back.
if (NewName.startswith("::") && NewName.substr(2) == ReplacedName)
ReplacedName = NewName.str();
}
Replace(RenameInfo.Begin, RenameInfo.End, ReplacedName);
}
// Hanlde using declarations explicitly as "using a::Foo" don't trigger
// typeLoc for "a::Foo".
for (const auto *Using : Finder.getUsingDecls())
Replace(Using->getBeginLoc(), Using->getEndLoc(), "using " + NewName.str());
return AtomicChanges;
}
} // end namespace tooling
} // end namespace clang
