Move the functionality of ASTContext::getCanonicalDecl(), into a virtual method Decl...

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@76273 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/AST/Decl.h b/include/clang/AST/Decl.h
index a5c3ea0680e75f3374511e06d9aea5abaf67ba42..a35638f3157d07fd08962e19fb80bfcf7251ecb1 100644 (file)
--- a/include/clang/AST/Decl.h
+++ b/include/clang/AST/Decl.h
@@ -437,7 +437,7 @@ public:
     return First->PreviousDeclaration.getPointer();
   }
 
-  virtual Decl *getPrimaryDecl() const;
+  virtual VarDecl *getCanonicalDecl();
 
   /// \brief Iterates through all the redeclarations of the same var decl.
   class redecl_iterator {
@@ -908,7 +908,7 @@ public:
 
   void setPreviousDeclaration(FunctionDecl * PrevDecl);
 
-  virtual Decl *getPrimaryDecl() const;
+  virtual FunctionDecl *getCanonicalDecl();
 
   /// \brief Iterates through all the redeclarations of the same function decl.
   class redecl_iterator {
@@ -1316,6 +1316,8 @@ public:
   void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
 
   virtual SourceRange getSourceRange() const;
+  
+  virtual TagDecl* getCanonicalDecl();
 
   /// isDefinition - Return true if this decl has its body specified.
   bool isDefinition() const {

diff --git a/include/clang/AST/DeclBase.h b/include/clang/AST/DeclBase.h
index 2d056c479b62b02019ce0aed70d7112565691bcf..5350706ae0c44fcd89ee93d7301d36254e3721b7 100644 (file)
--- a/include/clang/AST/DeclBase.h
+++ b/include/clang/AST/DeclBase.h
@@ -312,12 +312,14 @@ public:
   // be defined inside or outside a function etc).
   bool isDefinedOutsideFunctionOrMethod() const;
 
-  /// \brief When there are multiple re-declarations (e.g. for functions),
-  /// this will return the primary one which all of them point to.
-  virtual Decl *getPrimaryDecl() const { return const_cast<Decl*>(this); }
+  /// \brief Retrieves the "canonical" declaration of the given declaration.
+  virtual Decl *getCanonicalDecl() { return this; }
+  const Decl *getCanonicalDecl() const {
+    return const_cast<Decl*>(this)->getCanonicalDecl();
+  }
 
   /// \brief Whether this particular Decl is a primary one.
-  bool isPrimaryDecl() const { return getPrimaryDecl() == this; }
+  bool isCanonicalDecl() const { return getCanonicalDecl() == this; }
 
   /// getBody - If this Decl represents a declaration for a body of code,
   ///  such as a function or method definition, this method returns the

diff --git a/include/clang/AST/DeclTemplate.h b/include/clang/AST/DeclTemplate.h
index 5d0fe158e054fe795480d00fcb19650d7c55436e..8601620931315bf4d0ddb1616c8356752977573d 100644 (file)
--- a/include/clang/AST/DeclTemplate.h
+++ b/include/clang/AST/DeclTemplate.h
@@ -604,6 +604,8 @@ public:
       CommonOrPrev = Prev;
   }
   
+  virtual FunctionTemplateDecl *getCanonicalDecl();
+  
   /// Create a template function node.
   static FunctionTemplateDecl *Create(ASTContext &C, DeclContext *DC,
                                       SourceLocation L,
@@ -1027,6 +1029,8 @@ public:
   ClassTemplateDecl *getPreviousDeclaration() const {
     return PreviousDeclaration;
   }
+  
+  virtual ClassTemplateDecl *getCanonicalDecl();
 
   /// Create a class template node.
   static ClassTemplateDecl *Create(ASTContext &C, DeclContext *DC,

diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
index b43aadb62e4ac7188762858bfa032aa6c3fe2fa5..f680606dcfee22a12f035813a141e645c33054c7 100644 (file)
--- a/lib/AST/ASTContext.cpp
+++ b/lib/AST/ASTContext.cpp
@@ -2085,38 +2085,7 @@ QualType ASTContext::getCanonicalType(QualType T) {
 Decl *ASTContext::getCanonicalDecl(Decl *D) {
   if (!D)
     return 0;
-
-  if (TagDecl *Tag = dyn_cast<TagDecl>(D)) {
-    QualType T = getTagDeclType(Tag);
-    return cast<TagDecl>(cast<TagType>(T.getTypePtr()->CanonicalType)
-                         ->getDecl());
-  }
-
-  if (ClassTemplateDecl *Template = dyn_cast<ClassTemplateDecl>(D)) {
-    while (Template->getPreviousDeclaration())
-      Template = Template->getPreviousDeclaration();
-    return Template;
-  }
-
-  if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
-    while (Function->getPreviousDeclaration())
-      Function = Function->getPreviousDeclaration();
-    return const_cast<FunctionDecl *>(Function);
-  }
-
-  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) {
-    while (FunTmpl->getPreviousDeclaration())
-      FunTmpl = FunTmpl->getPreviousDeclaration();
-    return FunTmpl;
-  }
-  
-  if (const VarDecl *Var = dyn_cast<VarDecl>(D)) {
-    while (Var->getPreviousDeclaration())
-      Var = Var->getPreviousDeclaration();
-    return const_cast<VarDecl *>(Var);
-  }
-
-  return D;
+  return D->getCanonicalDecl();
 }
 
 TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) {

diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
index 728724f1b3d4da30863c9d9eb9747b45be5e3641..0a6f28d3fb7a29ef5e7601c96e22ea0b2e1ec620 100644 (file)
--- a/lib/AST/Decl.cpp
+++ b/lib/AST/Decl.cpp
@@ -387,8 +387,11 @@ VarDecl *VarDecl::getFirstDeclaration() {
   return First;
 }
 
-Decl *VarDecl::getPrimaryDecl() const {
-  return const_cast<VarDecl *>(getFirstDeclaration());
+VarDecl *VarDecl::getCanonicalDecl() {
+  VarDecl *Var = this;
+  while (Var->getPreviousDeclaration())
+    Var = Var->getPreviousDeclaration();
+  return Var;
 }
 
 //===----------------------------------------------------------------------===//
@@ -621,8 +624,11 @@ FunctionDecl *FunctionDecl::getFirstDeclaration() {
   return First;
 }
 
-Decl *FunctionDecl::getPrimaryDecl() const {
-  return const_cast<FunctionDecl *>(getFirstDeclaration());
+FunctionDecl *FunctionDecl::getCanonicalDecl() {
+  FunctionDecl *FD = this;
+  while (FD->getPreviousDeclaration())
+    FD = FD->getPreviousDeclaration();
+  return FD;
 }
 
 /// getOverloadedOperator - Which C++ overloaded operator this
@@ -703,6 +709,14 @@ SourceRange TagDecl::getSourceRange() const {
   return SourceRange(getLocation(), E);
 }
 
+TagDecl* TagDecl::getCanonicalDecl() {
+  Type *T = getTypeForDecl();
+  if (T == 0)
+    T = getASTContext().getTagDeclType(this).getTypePtr();
+
+  return cast<TagDecl>(cast<TagType>(T->getCanonicalTypeInternal())->getDecl());
+}
+
 void TagDecl::startDefinition() {
   TagType *TagT = const_cast<TagType *>(TypeForDecl->getAsTagType());
   TagT->decl.setPointer(this);

diff --git a/lib/AST/DeclTemplate.cpp b/lib/AST/DeclTemplate.cpp
index f1bd1b67d21e9d5961fc0fd34fd5ed14b5fbb15c..e096e41aed2e31796e1a06ebdffb102a6d34ae4c 100644 (file)
--- a/lib/AST/DeclTemplate.cpp
+++ b/lib/AST/DeclTemplate.cpp
@@ -98,6 +98,13 @@ void FunctionTemplateDecl::Destroy(ASTContext &C) {
   Decl::Destroy(C);
 }
 
+FunctionTemplateDecl *FunctionTemplateDecl::getCanonicalDecl() {
+  FunctionTemplateDecl *FunTmpl = this;
+  while (FunTmpl->getPreviousDeclaration())
+    FunTmpl = FunTmpl->getPreviousDeclaration();
+  return FunTmpl;
+}
+
 FunctionTemplateDecl::Common *FunctionTemplateDecl::getCommonPtr() {
   // Find the first declaration of this function template.
   FunctionTemplateDecl *First = this;
@@ -115,6 +122,13 @@ FunctionTemplateDecl::Common *FunctionTemplateDecl::getCommonPtr() {
 // ClassTemplateDecl Implementation
 //===----------------------------------------------------------------------===//
 
+ClassTemplateDecl *ClassTemplateDecl::getCanonicalDecl() {
+  ClassTemplateDecl *Template = this;
+  while (Template->getPreviousDeclaration())
+    Template = Template->getPreviousDeclaration();
+  return Template;
+}
+
 ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
                                              DeclContext *DC,
                                              SourceLocation L,

diff --git a/lib/Index/DeclReferenceMap.cpp b/lib/Index/DeclReferenceMap.cpp
index 3ec8794b379bf928298cf6b13719909b735b15e2..2e5e7c389a1ab76606e20e3de5742d78b1cad3cf 100644 (file)
--- a/lib/Index/DeclReferenceMap.cpp
+++ b/lib/Index/DeclReferenceMap.cpp
@@ -66,12 +66,12 @@ void StmtMapper::VisitDeclStmt(DeclStmt *Node) {
 }
 
 void StmtMapper::VisitDeclRefExpr(DeclRefExpr *Node) {
-  NamedDecl *PrimD = cast<NamedDecl>(Node->getDecl()->getPrimaryDecl());
+  NamedDecl *PrimD = cast<NamedDecl>(Node->getDecl()->getCanonicalDecl());
   Map.insert(std::make_pair(PrimD, ASTLocation(Parent, Node)));
 }
 
 void StmtMapper::VisitMemberExpr(MemberExpr *Node) {
-  NamedDecl *PrimD = cast<NamedDecl>(Node->getMemberDecl()->getPrimaryDecl());
+  NamedDecl *PrimD = cast<NamedDecl>(Node->getMemberDecl()->getCanonicalDecl());
   Map.insert(std::make_pair(PrimD, ASTLocation(Parent, Node)));
 }
 
@@ -122,17 +122,17 @@ DeclReferenceMap::DeclReferenceMap(ASTContext &Ctx) {
 
 DeclReferenceMap::astlocation_iterator
 DeclReferenceMap::refs_begin(NamedDecl *D) const {
-  NamedDecl *Prim = cast<NamedDecl>(D->getPrimaryDecl());
+  NamedDecl *Prim = cast<NamedDecl>(D->getCanonicalDecl());
   return astlocation_iterator(Map.lower_bound(Prim));  
 }
 
 DeclReferenceMap::astlocation_iterator
 DeclReferenceMap::refs_end(NamedDecl *D) const {
-  NamedDecl *Prim = cast<NamedDecl>(D->getPrimaryDecl());
+  NamedDecl *Prim = cast<NamedDecl>(D->getCanonicalDecl());
   return astlocation_iterator(Map.upper_bound(Prim));  
 }
 
 bool DeclReferenceMap::refs_empty(NamedDecl *D) const {
-  NamedDecl *Prim = cast<NamedDecl>(D->getPrimaryDecl());
+  NamedDecl *Prim = cast<NamedDecl>(D->getCanonicalDecl());
   return refs_begin(Prim) == refs_end(Prim);  
 }