[clang-rename] Fix rename on variable templates.

[hokein]

Summary

This patch adds support for renaming variable templates.

[kbobyrev]

Oh, that's neat, thanks!

clang/include/clang/AST/DeclTemplate.h

3098

I believe these are from https://reviews.llvm.org/D89221, so probably rebase on top of it?

[hokein]

clang/include/clang/AST/DeclTemplate.h

3098

I think you mean the change in D89220? they are different, this is for VarTemplateDecl, while that one is for ClassTemplateDecl.

[kbobyrev]

clang/include/clang/AST/DeclTemplate.h

3098

Ah, you're right, sorry!

clang/include/clang/AST/DeclTemplate.h

protected:
 
   /// Retrieve the set of specializations of this variable template.
   llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
   getSpecializations() const;
 
   /// Retrieve the set of partial specializations of this class
   /// template.
   llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
-  getPartialSpecializations();
+  getPartialSpecializations() const;
 
   VarTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
                   DeclarationName Name, TemplateParameterList *Params,
                   NamedDecl *Decl)
       : RedeclarableTemplateDecl(VarTemplate, C, DC, L, Name, Params, Decl) {}
 
   CommonBase *newCommon(ASTContext &C) const override;
 
public:
 
   /// Insert the specified partial specialization knowing that it is not
   /// already in. InsertPos must be obtained from findPartialSpecialization.
   void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D,
                                 void *InsertPos);
 
   /// Retrieve the partial specializations as an ordered list.
   void getPartialSpecializations(
-      SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS);
+      SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS) const;
 
   /// Find a variable template partial specialization which was
   /// instantiated
   /// from the given member partial specialization.
   ///
   /// \param D a member variable template partial specialization.
   ///
   /// \returns the variable template partial specialization which was

clang/lib/AST/DeclTemplate.cpp

 
 llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
 VarTemplateDecl::getSpecializations() const {
   LoadLazySpecializations();
   return getCommonPtr()->Specializations;
 }
 
 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
-VarTemplateDecl::getPartialSpecializations() {
+VarTemplateDecl::getPartialSpecializations() const {
   LoadLazySpecializations();
   return getCommonPtr()->PartialSpecializations;
 }
 
 RedeclarableTemplateDecl::CommonBase *
 VarTemplateDecl::newCommon(ASTContext &C) const {
   auto *CommonPtr = new (C) Common;
   C.addDestruction(CommonPtr);
else {
     assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
   }
 
   if (ASTMutationListener *L = getASTMutationListener())
     L->AddedCXXTemplateSpecialization(this, D);
 }
 
 void VarTemplateDecl::getPartialSpecializations(
-    SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS) {
+    SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS) const {
   llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &PartialSpecs =
       getPartialSpecializations();
   PS.clear();
   PS.reserve(PartialSpecs.size());
   for (VarTemplatePartialSpecializationDecl &P : PartialSpecs)
     PS.push_back(P.getMostRecentDecl());
 }
 

clang/lib/Tooling/Refactoring/Rename/USRFindingAction.cpp

if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(FoundDecl)) {
                    dyn_cast<ClassTemplateDecl>(FoundDecl)) {
       handleClassTemplateDecl(TemplateDecl);
     } else if (const auto *FD = dyn_cast<FunctionDecl>(FoundDecl)) {
       USRSet.insert(getUSRForDecl(FD));
       if (const auto *FTD = FD->getPrimaryTemplate())
         handleFunctionTemplateDecl(FTD);
     } else if (const auto *FD = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
       handleFunctionTemplateDecl(FD);
+    } else if (const auto *VTD = dyn_cast<VarTemplateDecl>(FoundDecl)) {
+      handleVarTemplateDecl(VTD);
+    } else if (const auto *VD =
+                   dyn_cast<VarTemplateSpecializationDecl>(FoundDecl)) {
+      // FIXME: figure out why FoundDecl can be a VarTemplateSpecializationDecl.
+      handleVarTemplateDecl(VD->getSpecializedTemplate());
+    } else if (const auto *VD = dyn_cast<VarDecl>(FoundDecl)) {
+      USRSet.insert(getUSRForDecl(VD));
+      if (const auto *VTD = VD->getDescribedVarTemplate())
+        handleVarTemplateDecl(VTD);
     } else {
       USRSet.insert(getUSRForDecl(FoundDecl));
     }
     return std::vector<std::string>(USRSet.begin(), USRSet.end());
   }
 
   bool shouldVisitTemplateInstantiations() const { return true; }
 
private:
 
   void handleFunctionTemplateDecl(const FunctionTemplateDecl *FTD) {
     USRSet.insert(getUSRForDecl(FTD));
     USRSet.insert(getUSRForDecl(FTD->getTemplatedDecl()));
     for (const auto *S : FTD->specializations())
       USRSet.insert(getUSRForDecl(S));
   }
 
+  void handleVarTemplateDecl(const VarTemplateDecl *VTD) {
+    USRSet.insert(getUSRForDecl(VTD));
+    USRSet.insert(getUSRForDecl(VTD->getTemplatedDecl()));
+    llvm::for_each(VTD->specializations(), [&](const auto *Spec) {
+      USRSet.insert(getUSRForDecl(Spec));
+    });
+    SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
+    VTD->getPartialSpecializations(PartialSpecs);
+    llvm::for_each(PartialSpecs, [&](const auto *Spec) {
+      USRSet.insert(getUSRForDecl(Spec));
+    });
+  }
+
   void addUSRsOfCtorDtors(const CXXRecordDecl *RD) {
     const auto* RecordDecl = RD->getDefinition();
 
     // Skip if the CXXRecordDecl doesn't have definition.
     if (!RecordDecl) {
       USRSet.insert(getUSRForDecl(RD));
       return;
     }

clang/test/clang-rename/VariableTemplate.cpp

+template <typename T, int U>
+bool Foo = true;  // CHECK: bool Bar = true;
+
+// explicit template specialization
+template <>
+bool Foo<int, 0> = false; // CHECK: bool Bar<int, 0> = false;
+
+// partial template specialization
+template <typename T>
+bool Foo<T, 1> = false; // bool Bar<x, 1> = false;
+
+void k() {
+  // ref to the explicit template specialization
+  Foo<int, 0>;   // CHECK: Bar<int, 0>;
+  // ref to the primary template.
+  Foo<double, 2>;   // CHECK: Bar<double, 2>;
+}
+
+
+// Test 1.
+// RUN: clang-rename -offset=34 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// Test 2.
+// RUN: clang-rename -offset=128 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// Test 3.
+// RUN: clang-rename -offset=248 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// Test 4.
+// RUN: clang-rename -offset=357 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+// Test 5.
+// RUN: clang-rename -offset=431 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
+
+// To find offsets after modifying the file, use:
+//   grep -Ubo 'Foo.*' <file>