[rename] Use SymbolOccurrence in RenameLocFinder.

[hokein]

Summary

This is first step to integrate qualified rename into clang-refactor.

Also a few changes to SymbolOccurrence:

• add more information to SymbolOccurrence
• remove the way of using SourceLocation as the array size

[ioeric]

Could you elaborate on the intention of this change? Is the intention of having more information in SymbolOccurrence to benefit users of the rename library or to simplify the internal implementation?

include/clang/Tooling/Refactoring/Rename/SymbolOccurrences.h

74

A SymbolOccurrence is likely to out-live an AST (e.g. when used in clang-refactor or serialized to files), so it might not be safe to store references to ASTs here. If we really want AST information in the SymbolOccurrence, we could probably derive from it and use only internally. But it doesn't make sense to pass AST references out to users.

[hokein]

include/clang/Tooling/Refactoring/Rename/SymbolOccurrences.h

74

Yeah, right. It is not a good idea to add AST information in the SymbolOccurrence as it is out range of Rule. On the second thought, we don't need to add this information. Let's close this revision.

include/clang/Tooling/Refactoring/Rename/SymbolOccurrences.h

 //===--- SymbolOccurrences.h - Clang refactoring library ------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLING_REFACTOR_RENAME_SYMBOL_OCCURRENCES_H
 #define LLVM_CLANG_TOOLING_REFACTOR_RENAME_SYMBOL_OCCURRENCES_H
 
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
+#include "clang/Tooling/Refactoring/Rename/SymbolName.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include <vector>
 
 namespace clang {
-namespace tooling {
 
-class SymbolName;
+class Decl;
+class NamedDecl;
+class NestedNameSpecifier;
+
+namespace tooling {
 
 /// An occurrence of a symbol in the source.
 ///
 /// Occurrences can have difference kinds, that describe whether this occurrence
 /// is an exact semantic match, or whether this is a weaker textual match that's
 /// not guaranteed to represent the exact declaration.
 ///
 /// A single occurrence of a symbol can span more than one source range. For
enum OccurrenceKind {
     /// \endcode
     ///
     /// The user will have to fix their code manually after performing such a
     /// rename.
     /// FIXME: The rename verifier should notify user about this issue.
     MatchingSymbol
   };
 
+  // A context for qualified rename, it is used to calculate the fewest prefix
+  // qualifiers for the symbol occurrence.
+  struct SymbolContext {
+    // 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;
+  };
+
   SymbolOccurrence(const SymbolName &Name, OccurrenceKind Kind,
                    ArrayRef<SourceLocation> Locations);
 
   SymbolOccurrence(SymbolOccurrence &&) = default;
   SymbolOccurrence &operator=(SymbolOccurrence &&) = default;
 
   OccurrenceKind getKind() const { return Kind; }
 
   ArrayRef<SourceRange> getNameRanges() const {
-    if (MultipleRanges) {
-      return llvm::makeArrayRef(MultipleRanges.get(),
-                                RangeOrNumRanges.getBegin().getRawEncoding());
-    }
-    return RangeOrNumRanges;
+    return llvm::makeArrayRef(Ranges.get(), Name.getNamePieces().size());
+
+  const SymbolName& getSymbolName() const {
+    return Name;
+  }
+
+  void setSymbolContext(SymbolContext SC) {
+    Context = std::move(SC);
+  }
+
+  llvm::Optional<SymbolContext> getSymbolContext() const {
+    return Context;
   }
 
 private:
+  SymbolName Name;
   OccurrenceKind Kind;
-  std::unique_ptr<SourceRange[]> MultipleRanges;
-  SourceRange RangeOrNumRanges;
+  std::unique_ptr<SourceRange[]> Ranges;
+  // Empty if the rename operation is not qualified rename.
+  llvm::Optional<SymbolContext> Context;
 };
 
 using SymbolOccurrences = std::vector<SymbolOccurrence>;
 
 } // end namespace tooling
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLING_REFACTOR_RENAME_SYMBOL_OCCURRENCES_H

lib/Tooling/Refactoring/Rename/SymbolOccurrences.cpp

 #include "clang/Tooling/Refactoring/Rename/SymbolName.h"
 #include "llvm/ADT/STLExtras.h"
 
 using namespace clang;
 using namespace tooling;
 
 SymbolOccurrence::SymbolOccurrence(const SymbolName &Name, OccurrenceKind Kind,
                                    ArrayRef<SourceLocation> Locations)
-    : Kind(Kind) {
+    : Name(Name), Kind(Kind) {
   ArrayRef<std::string> NamePieces = Name.getNamePieces();
   assert(Locations.size() == NamePieces.size() &&
          "mismatching number of locations and lengths");
   assert(!Locations.empty() && "no locations");
-  if (Locations.size() == 1) {
-    RangeOrNumRanges = SourceRange(
-        Locations[0], Locations[0].getLocWithOffset(NamePieces[0].size()));
-    return;
-  }
-  MultipleRanges = llvm::make_unique<SourceRange[]>(Locations.size());
-  RangeOrNumRanges.setBegin(
-      SourceLocation::getFromRawEncoding(Locations.size()));
+  Ranges = llvm::make_unique<SourceRange[]>(Locations.size());
   for (const auto &Loc : llvm::enumerate(Locations)) {
-    MultipleRanges[Loc.index()] = SourceRange(
+    Ranges[Loc.index()] = SourceRange(
         Loc.value(),
         Loc.value().getLocWithOffset(NamePieces[Loc.index()].size()));
   }
 }

lib/Tooling/Refactoring/Rename/USRLocFinder.cpp

 //
 // 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);
+        addSymbolOccurence(StartLoc, EndLoc);
       }
     }
     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});
+      addSymbolOccurence(StartLoc, EndLoc);
     }
     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});
+          addSymbolOccurence(Loc, Loc);
         }
       }
     }
     return true;
   }
 
   bool VisitDeclRefExpr(const DeclRefExpr *Expr) {
     const NamedDecl *Decl = Expr->getFoundDecl();
SourceLocation EndLoc = Expr->hasExplicitTemplateArgs()
                                 ? Expr->getLAngleLoc().getLocWithOffset(-1)
                                 : Expr->getLocEnd();
 
     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});
+        addSymbolOccurence(EndLoc, EndLoc);
         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
if (const auto *T = llvm::dyn_cast<EnumConstantDecl>(Decl)) {
       // 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,
+      addSymbolOccurence(StartLoc,
                          EndLoc,
                          Decl,
                          getClosestAncestorDecl(*Expr),
                          Expr->getQualifier(),
-                         /*IgnorePrefixQualifers=*/false};
-      RenameInfos.push_back(Info);
+                         /*IgnorePrefixQualifers=*/false);
     }
 
     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(),
+        addSymbolOccurence(NestedLoc.getBeginLoc(),
                            EndLocationForType(NestedLoc.getTypeLoc()),
-                           TargetDecl,
-                           getClosestAncestorDecl(NestedLoc),
+                           TargetDecl, getClosestAncestorDecl(NestedLoc),
                            NestedLoc.getNestedNameSpecifier()->getPrefix(),
-                           /*IgnorePrefixQualifers=*/false};
-        RenameInfos.push_back(Info);
+                           /*IgnorePrefixQualifers=*/false);
       }
     }
     return true;
   }
 
   bool VisitTypeLoc(TypeLoc Loc) {
     auto Parents = Context.getParents(Loc);
     TypeLoc ParentTypeLoc;
if (const auto *TargetDecl = getSupportedDeclFromTypeLoc(Loc)) {
         // 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,
+          addSymbolOccurence(StartLoc,
                              EndLoc,
                              TargetDecl,
                              getClosestAncestorDecl(Loc),
                              GetNestedNameForType(Loc),
-                             /*IgnorePrefixQualifers=*/false};
-          RenameInfos.push_back(Info);
+                             /*IgnorePrefixQualifers=*/false);
         }
         return true;
       }
     }
 
     // Handle specific template class specialiation cases.
     if (const auto *TemplateSpecType =
             dyn_cast<TemplateSpecializationType>(Loc.getType())) {
if (const auto *TemplateSpecType =
         // 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,
+          addSymbolOccurence(
+              StartLoc, EndLoc,
               TemplateSpecType->getTemplateName().getAsTemplateDecl(),
               getClosestAncestorDecl(
                   ast_type_traits::DynTypedNode::create(TargetLoc)),
               GetNestedNameForType(TargetLoc),
-              /*IgnorePrefixQualifers=*/false};
-          RenameInfos.push_back(Info);
+              /*IgnorePrefixQualifers=*/false);
         }
       }
     }
     return true;
   }
 
-  // Returns a list of RenameInfo.
-  const std::vector<RenameInfo> &getRenameInfos() const { return RenameInfos; }
+  void addSymbolOccurence(SourceLocation StartLoc, SourceLocation EndLoc,
+                          const NamedDecl *FromDecl = nullptr,
+                          const Decl *DeclContext = nullptr,
+                          const NestedNameSpecifier *Specifier = nullptr,
+                          bool IgnorePrefixQualifers = true) {
+    const auto& SM = Context.getSourceManager();
+    StringRef QualifiedName = Lexer::getSourceText(
+        CharSourceRange::getTokenRange(SM.getSpellingLoc(StartLoc),
+                                       SM.getSpellingLoc(EndLoc)),
+        SM, Context.getLangOpts());
+    SymbolOccurrence::SymbolContext SC = {FromDecl, DeclContext, Specifier,
+                                          IgnorePrefixQualifers};
+    SymbolOccurrence Occurrence(SymbolName(QualifiedName),
+                                SymbolOccurrence::MatchingSymbol,
+                                SM.getSpellingLoc(StartLoc));
+    Occurrence.setSymbolContext(SC);
+    Occurences.push_back(std::move(Occurrence));
+  }
+
+  SymbolOccurrences takeOccurences() { return std::move(Occurences); }
 
   // 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
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;
+  SymbolOccurrences Occurences;
   // 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);
+  auto Replace = [&](CharSourceRange Range, llvm::StringRef Text) {
+    tooling::AtomicChange ReplaceChange = tooling::AtomicChange(
+        SM, Range.getBegin());
+    llvm::Error Err = ReplaceChange.replace(SM, Range, Text);
     if (Err) {
       llvm::errs() << "Faile to add replacement to AtomicChange: "
                    << llvm::toString(std::move(Err)) << "\n";
       return;
     }
     AtomicChanges.push_back(std::move(ReplaceChange));
   };
 
-  for (const auto &RenameInfo : Finder.getRenameInfos()) {
+  for (const auto &Occurrence: Finder.takeOccurences()) {
     std::string ReplacedName = NewName.str();
-    if (RenameInfo.IgnorePrefixQualifers) {
+    assert(Occurrence.getSymbolContext() &&
+           "Occurrence in qualified rename should have Context.");
+    assert(Occurrence.getSymbolName().getNamePieces().size() == 1 &&
+           "Qualified rename doesn't support symbol name composed of "
+           "multiple strings.");
+    const auto& OccurrenceContext = *Occurrence.getSymbolContext();
+    if (OccurrenceContext.IgnorePrefixQualifers) {
       // Get the name without prefix qualifiers from NewName.
       size_t LastColonPos = NewName.find_last_of(':');
       if (LastColonPos != std::string::npos)
         ReplacedName = NewName.substr(LastColonPos + 1);
     } else {
-      if (RenameInfo.FromDecl && RenameInfo.Context) {
+      if (OccurrenceContext.FromDecl && OccurrenceContext.Context) {
         if (!llvm::isa<clang::TranslationUnitDecl>(
-                RenameInfo.Context->getDeclContext())) {
+                OccurrenceContext.Context->getDeclContext())) {
           ReplacedName = tooling::replaceNestedName(
-              RenameInfo.Specifier, RenameInfo.Context->getDeclContext(),
-              RenameInfo.FromDecl,
+              OccurrenceContext.Specifier,
+              OccurrenceContext.Context->getDeclContext(),
+              OccurrenceContext.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());
+          llvm::StringRef ActualName =
+              Occurrence.getSymbolName().getNamePieces()[0];
           // 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);
+    Replace(
+        CharSourceRange::getCharRange(Occurrence.getNameRanges()[0].getBegin(),
+                                      Occurrence.getNameRanges()[0].getEnd()),
+        ReplacedName);
   }
 
   // Hanlde using declarations explicitly as "using a::Foo" don't trigger
   // typeLoc for "a::Foo".
   for (const auto *Using : Finder.getUsingDecls())
-    Replace(Using->getLocStart(), Using->getLocEnd(), "using " + NewName.str());
+    Replace(CharSourceRange::getTokenRange(Using->getLocStart(),
+                                           Using->getLocEnd()),
+            "using " + NewName.str());
 
   return AtomicChanges;
 }
 
 } // end namespace tooling
 } // end namespace clang