Remove ASTContext::getCanonicalDecl() and use Decl::getCanonicalDecl in its place.

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

diff --git a/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h
index 19a4fbcdba20a81356e393b3838f6ea783d6d566..6e4c1d6eaeeaf64594e66d5dddbe8f499c77148b 100644 (file)
--- a/include/clang/AST/ASTContext.h
+++ b/include/clang/AST/ASTContext.h
@@ -643,19 +643,6 @@ public:
     return T1.getUnqualifiedType() == T2.getUnqualifiedType();
   }
 
-  /// \brief Retrieves the "canonical" declaration of the given declaration.
-  Decl *getCanonicalDecl(Decl *D);
-
-  /// \brief Retrieves the "canonical" declaration of the given tag
-  /// declaration.
-  ///
-  /// The canonical declaration for the given tag declaration is
-  /// either the definition of the tag (if it is a complete type) or
-  /// the first declaration of that tag.
-  TagDecl *getCanonicalDecl(TagDecl *Tag) {
-    return cast<TagDecl>(getCanonicalDecl((Decl *)Tag));
-  }
-
   /// \brief Retrieves the "canonical" declaration of 
 
   /// \brief Retrieves the "canonical" nested name specifier for a

diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
index f680606dcfee22a12f035813a141e645c33054c7..046b27c9f3207197dd75de117c047ffb1718a174 100644 (file)
--- a/lib/AST/ASTContext.cpp
+++ b/lib/AST/ASTContext.cpp
@@ -2082,17 +2082,11 @@ QualType ASTContext::getCanonicalType(QualType T) {
                               VAT->getBracketsRange());
 }
 
-Decl *ASTContext::getCanonicalDecl(Decl *D) {
-  if (!D)
-    return 0;
-  return D->getCanonicalDecl();
-}
-
 TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) {
   // If this template name refers to a template, the canonical
   // template name merely stores the template itself.
   if (TemplateDecl *Template = Name.getAsTemplateDecl())
-    return TemplateName(cast<TemplateDecl>(getCanonicalDecl(Template)));
+    return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl()));
 
   DependentTemplateName *DTN = Name.getAsDependentTemplateName();
   assert(DTN && "Non-dependent template names must refer to template decls.");

diff --git a/lib/AST/DeclTemplate.cpp b/lib/AST/DeclTemplate.cpp
index e096e41aed2e31796e1a06ebdffb102a6d34ae4c..ce382dbdad6c11942b376a1602cd50f1b07ed48b 100644 (file)
--- a/lib/AST/DeclTemplate.cpp
+++ b/lib/AST/DeclTemplate.cpp
@@ -200,7 +200,7 @@ QualType ClassTemplateDecl::getInjectedClassNameType(ASTContext &Context) {
       TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*Param);
       TemplateArgs.push_back(TemplateArgument(TTP->getLocation(), TTP));
       CanonTemplateArgs.push_back(TemplateArgument(TTP->getLocation(), 
-                                              Context.getCanonicalDecl(TTP)));
+                                                   TTP->getCanonicalDecl()));
     }
   }
 

diff --git a/lib/Sema/SemaLookup.cpp b/lib/Sema/SemaLookup.cpp
index c88321e1a355f52ab66222999b5088a1925d58a3..d9dea66f825714866ef14837ab2dd4ff58e3109d 100644 (file)
--- a/lib/Sema/SemaLookup.cpp
+++ b/lib/Sema/SemaLookup.cpp
@@ -217,7 +217,7 @@ MergeLookupResults(ASTContext &Context, LookupResultsTy &Results) {
       NamedDecl *ND = I->getAsDecl()->getUnderlyingDecl();
         
       if (TagDecl *TD = dyn_cast<TagDecl>(ND)) {
-        TagFound = Context.getCanonicalDecl(TD);
+        TagFound = TD->getCanonicalDecl();
         TagNames += FoundDecls.insert(TagFound)?  1 : 0;
       } else if (ND->isFunctionOrFunctionTemplate())
         Functions += FoundDecls.insert(ND)? 1 : 0;

diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index d0d61c6ed1a0e3dc67be8cb35f076fe0ef4a3b1d..503f226fd66c079a37b58e8f6f8bc84cbebf005d 100644 (file)
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -3764,7 +3764,7 @@ Sema::ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType,
         assert(FunctionType 
                  == Context.getCanonicalType(Specialization->getType()));
         Matches.insert(
-                cast<FunctionDecl>(Context.getCanonicalDecl(Specialization)));
+                cast<FunctionDecl>(Specialization->getCanonicalDecl()));
       }
     }
     
@@ -3778,7 +3778,7 @@ Sema::ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType,
 
     if (FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(*Fun)) {
       if (FunctionType == Context.getCanonicalType(FunDecl->getType())) {
-        Matches.insert(cast<FunctionDecl>(Context.getCanonicalDecl(*Fun)));
+        Matches.insert(cast<FunctionDecl>(Fun->getCanonicalDecl()));
         FoundNonTemplateFunction = true;
       }
     } 

diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp
index 568d68c9a7e82f714c1d1006d0832250051a9702..8fd9c58c83071ed80898cc8d5cf1131f515c70cd 100644 (file)
--- a/lib/Sema/SemaTemplate.cpp
+++ b/lib/Sema/SemaTemplate.cpp
@@ -56,7 +56,7 @@ TemplateNameKind Sema::isTemplateName(const IdentifierInfo &II, Scope *S,
       //   which could be the current specialization or another
       //   specialization.
       if (Record->isInjectedClassName()) {
-        Record = cast<CXXRecordDecl>(Context.getCanonicalDecl(Record));
+        Record = cast<CXXRecordDecl>(Record->getCanonicalDecl());
         if ((Template = Record->getDescribedClassTemplate()))
           TNK = TNK_Type_template;
         else if (ClassTemplateSpecializationDecl *Spec
@@ -795,7 +795,7 @@ static void CanonicalizeTemplateArguments(const TemplateArgument *TemplateArgs,
     case TemplateArgument::Declaration:
       Canonical.push_back(
                  TemplateArgument(SourceLocation(),
-                    Context.getCanonicalDecl(TemplateArgs[Idx].getAsDecl())));
+                            TemplateArgs[Idx].getAsDecl()->getCanonicalDecl()));
       break;
 
     case TemplateArgument::Integral:
@@ -1278,7 +1278,7 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
           
           // Add the converted template argument.
           Decl *D 
-            = Context.getCanonicalDecl(cast<DeclRefExpr>(ArgExpr)->getDecl());
+            = cast<DeclRefExpr>(ArgExpr)->getDecl()->getCanonicalDecl();
           Converted.Append(TemplateArgument(Arg.getLocation(), D));
           continue;
         }
@@ -1702,7 +1702,8 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
       if (CheckTemplateArgumentPointerToMember(Arg, Member))
         return true;
 
-      Member = cast_or_null<NamedDecl>(Context.getCanonicalDecl(Member));
+      if (Member)
+        Member = cast<NamedDecl>(Member->getCanonicalDecl());
       Converted = TemplateArgument(StartLoc, Member);
       return false;
     }
@@ -1711,7 +1712,8 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
     if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity))
       return true;
 
-    Entity = cast_or_null<NamedDecl>(Context.getCanonicalDecl(Entity));
+    if (Entity)
+      Entity = cast<NamedDecl>(Entity->getCanonicalDecl());
     Converted = TemplateArgument(StartLoc, Entity);
     return false;
   }
@@ -1750,7 +1752,8 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
     if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity))
       return true;
 
-    Entity = cast_or_null<NamedDecl>(Context.getCanonicalDecl(Entity));
+    if (Entity)
+      Entity = cast<NamedDecl>(Entity->getCanonicalDecl());
     Converted = TemplateArgument(StartLoc, Entity);
     return false;
   }
@@ -1791,7 +1794,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
     if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity))
       return true;
 
-    Entity = cast<NamedDecl>(Context.getCanonicalDecl(Entity));
+    Entity = cast<NamedDecl>(Entity->getCanonicalDecl());
     Converted = TemplateArgument(StartLoc, Entity);
     return false;
   }
@@ -1820,7 +1823,8 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
   if (CheckTemplateArgumentPointerToMember(Arg, Member))
     return true;
   
-  Member = cast_or_null<NamedDecl>(Context.getCanonicalDecl(Member));
+  if (Member)
+    Member = cast<NamedDecl>(Member->getCanonicalDecl());
   Converted = TemplateArgument(StartLoc, Member);
   return false;
 }

diff --git a/lib/Sema/SemaTemplateDeduction.cpp b/lib/Sema/SemaTemplateDeduction.cpp
index f6f9d105d95d16d889fae6430ef7917d72073ff8..80e0da1adc1d04de264d55dbb8f937ab3c5778fd 100644 (file)
--- a/lib/Sema/SemaTemplateDeduction.cpp
+++ b/lib/Sema/SemaTemplateDeduction.cpp
@@ -170,8 +170,8 @@ DeduceTemplateArguments(ASTContext &Context,
     return Sema::TDK_Inconsistent;
   }
 
-  ParamDecl = cast<TemplateDecl>(Context.getCanonicalDecl(ParamDecl));
-  ArgDecl = cast<TemplateDecl>(Context.getCanonicalDecl(ArgDecl));
+  ParamDecl = cast<TemplateDecl>(ParamDecl->getCanonicalDecl());
+  ArgDecl = cast<TemplateDecl>(ArgDecl->getCanonicalDecl());
   if (ParamDecl != ArgDecl) {
     // FIXME: fill in Info.Param/Info.FirstArg
     return Sema::TDK_Inconsistent;
@@ -799,8 +799,8 @@ static bool isSameTemplateArg(ASTContext &Context,
              Context.getCanonicalType(Y.getAsType());
       
     case TemplateArgument::Declaration:
-      return Context.getCanonicalDecl(X.getAsDecl()) ==
-             Context.getCanonicalDecl(Y.getAsDecl());
+      return X.getAsDecl()->getCanonicalDecl() ==
+             Y.getAsDecl()->getCanonicalDecl();
       
     case TemplateArgument::Integral:
       return *X.getAsIntegral() == *Y.getAsIntegral();

diff --git a/lib/Sema/SemaTemplateInstantiate.cpp b/lib/Sema/SemaTemplateInstantiate.cpp
index 6ee50ab98caf6594fa58c44c83157537011132c6..c50faad58744e0a179a2e5e8a2c9e28f58426907 100644 (file)
--- a/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/lib/Sema/SemaTemplateInstantiate.cpp
@@ -968,7 +968,7 @@ Sema::InstantiateClassTemplateSpecialization(
                            bool ExplicitInstantiation) {
   // Perform the actual instantiation on the canonical declaration.
   ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
-                               Context.getCanonicalDecl(ClassTemplateSpec));
+                                         ClassTemplateSpec->getCanonicalDecl());
 
   // We can only instantiate something that hasn't already been
   // instantiated or specialized. Fail without any diagnostics: our

diff --git a/lib/Sema/SemaTemplateInstantiateDecl.cpp b/lib/Sema/SemaTemplateInstantiateDecl.cpp
index 8ff80af19030d0ba76e21902a7b44dd9aa74e0dd..49271893f93bd205b9e2d250934310e00e02404b 100644 (file)
--- a/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -781,16 +781,16 @@ static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) {
     return false;
 
   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Other))
-    return Ctx.getCanonicalDecl(Record->getInstantiatedFromMemberClass())
-             == Ctx.getCanonicalDecl(D);
+    return Record->getInstantiatedFromMemberClass()->getCanonicalDecl()
+             == D->getCanonicalDecl();
 
   if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Other))
-    return Ctx.getCanonicalDecl(Function->getInstantiatedFromMemberFunction())
-             == Ctx.getCanonicalDecl(D);
+    return Function->getInstantiatedFromMemberFunction()->getCanonicalDecl()
+             == D->getCanonicalDecl();
 
   if (EnumDecl *Enum = dyn_cast<EnumDecl>(Other))
-    return Ctx.getCanonicalDecl(Enum->getInstantiatedFromMemberEnum())
-             == Ctx.getCanonicalDecl(D);
+    return Enum->getInstantiatedFromMemberEnum()->getCanonicalDecl()
+             == D->getCanonicalDecl();
 
   // FIXME: How can we find instantiations of anonymous unions?
 
@@ -891,8 +891,8 @@ NamedDecl * Sema::InstantiateCurrentDeclRef(NamedDecl *D) {
            DC = DC->getParent()) {
         if (ClassTemplateSpecializationDecl *Spec 
               = dyn_cast<ClassTemplateSpecializationDecl>(DC))
-          if (Context.getCanonicalDecl(Spec->getSpecializedTemplate())
-              == Context.getCanonicalDecl(ClassTemplate))
+          if (Spec->getSpecializedTemplate()->getCanonicalDecl()
+              == ClassTemplate->getCanonicalDecl())
             return Spec;
       }