Revert r295284: Add better ODR checking for modules.

Fix modules build bot.


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

1 files changed, 84 insertions, 145 deletions

diff --git a/lib/AST/StmtProfile.cpp b/lib/AST/StmtProfile.cpp
index 1ac2a5bf5e..49e43de638 100644
--- a/lib/AST/StmtProfile.cpp
+++ b/lib/AST/StmtProfile.cpp
@@ -19,22 +19,20 @@
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
-#include "clang/AST/ODRHash.h"
 #include "clang/AST/StmtVisitor.h"
 #include "llvm/ADT/FoldingSet.h"
 using namespace clang;
 
 namespace {
   class StmtProfiler : public ConstStmtVisitor<StmtProfiler> {
-  protected:
     llvm::FoldingSetNodeID &ID;
+    const ASTContext &Context;
     bool Canonical;
 
   public:
-    StmtProfiler(llvm::FoldingSetNodeID &ID, bool Canonical)
-        : ID(ID), Canonical(Canonical) {}
-
-    virtual ~StmtProfiler() {}
+    StmtProfiler(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
+                 bool Canonical)
+      : ID(ID), Context(Context), Canonical(Canonical) { }
 
     void VisitStmt(const Stmt *S);
 
@@ -43,25 +41,22 @@ namespace {
 
     /// \brief Visit a declaration that is referenced within an expression
     /// or statement.
-    virtual void VisitDecl(const Decl *D) = 0;
+    void VisitDecl(const Decl *D);
 
     /// \brief Visit a type that is referenced within an expression or
     /// statement.
-    virtual void VisitType(QualType T) = 0;
+    void VisitType(QualType T);
 
     /// \brief Visit a name that occurs within an expression or statement.
-    virtual void VisitName(DeclarationName Name) = 0;
-
-    /// \brief Visit identifiers that are not in Decl's or Type's.
-    virtual void VisitIdentifierInfo(IdentifierInfo *II) = 0;
+    void VisitName(DeclarationName Name);
 
     /// \brief Visit a nested-name-specifier that occurs within an expression
     /// or statement.
-    virtual void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) = 0;
+    void VisitNestedNameSpecifier(NestedNameSpecifier *NNS);
 
     /// \brief Visit a template name that occurs within an expression or
     /// statement.
-    virtual void VisitTemplateName(TemplateName Name) = 0;
+    void VisitTemplateName(TemplateName Name);
 
     /// \brief Visit template arguments that occur within an expression or
     /// statement.
@@ -71,127 +66,6 @@ namespace {
     /// \brief Visit a single template argument.
     void VisitTemplateArgument(const TemplateArgument &Arg);
   };
-
-  class StmtProfilerWithPointers : public StmtProfiler {
-    const ASTContext &Context;
-
-  public:
-    StmtProfilerWithPointers(llvm::FoldingSetNodeID &ID,
-                             const ASTContext &Context, bool Canonical)
-        : StmtProfiler(ID, Canonical), Context(Context) {}
-  private:
-    void VisitDecl(const Decl *D) override {
-      ID.AddInteger(D ? D->getKind() : 0);
-
-      if (Canonical && D) {
-        if (const NonTypeTemplateParmDecl *NTTP =
-                dyn_cast<NonTypeTemplateParmDecl>(D)) {
-          ID.AddInteger(NTTP->getDepth());
-          ID.AddInteger(NTTP->getIndex());
-          ID.AddBoolean(NTTP->isParameterPack());
-          VisitType(NTTP->getType());
-          return;
-        }
-
-        if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) {
-          // The Itanium C++ ABI uses the type, scope depth, and scope
-          // index of a parameter when mangling expressions that involve
-          // function parameters, so we will use the parameter's type for
-          // establishing function parameter identity. That way, our
-          // definition of "equivalent" (per C++ [temp.over.link]) is at
-          // least as strong as the definition of "equivalent" used for
-          // name mangling.
-          VisitType(Parm->getType());
-          ID.AddInteger(Parm->getFunctionScopeDepth());
-          ID.AddInteger(Parm->getFunctionScopeIndex());
-          return;
-        }
-
-        if (const TemplateTypeParmDecl *TTP =
-                dyn_cast<TemplateTypeParmDecl>(D)) {
-          ID.AddInteger(TTP->getDepth());
-          ID.AddInteger(TTP->getIndex());
-          ID.AddBoolean(TTP->isParameterPack());
-          return;
-        }
-
-        if (const TemplateTemplateParmDecl *TTP =
-                dyn_cast<TemplateTemplateParmDecl>(D)) {
-          ID.AddInteger(TTP->getDepth());
-          ID.AddInteger(TTP->getIndex());
-          ID.AddBoolean(TTP->isParameterPack());
-          return;
-        }
-      }
-
-      ID.AddPointer(D ? D->getCanonicalDecl() : nullptr);
-    }
-
-    void VisitType(QualType T) override {
-      if (Canonical)
-        T = Context.getCanonicalType(T);
-
-      ID.AddPointer(T.getAsOpaquePtr());
-    }
-
-    void VisitName(DeclarationName Name) override {
-      ID.AddPointer(Name.getAsOpaquePtr());
-    }
-
-    void VisitIdentifierInfo(IdentifierInfo *II) override {
-      ID.AddPointer(II);
-    }
-
-    void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) override {
-      if (Canonical)
-        NNS = Context.getCanonicalNestedNameSpecifier(NNS);
-      ID.AddPointer(NNS);
-    }
-
-    void VisitTemplateName(TemplateName Name) override {
-      if (Canonical)
-        Name = Context.getCanonicalTemplateName(Name);
-
-      Name.Profile(ID);
-    }
-  };
-
-  class StmtProfilerWithoutPointers : public StmtProfiler {
-    ODRHash &Hash;
-  public:
-    StmtProfilerWithoutPointers(llvm::FoldingSetNodeID &ID, ODRHash &Hash)
-        : StmtProfiler(ID, false), Hash(Hash) {}
-
-  private:
-    void VisitType(QualType T) override {
-      Hash.AddQualType(T);
-    }
-
-    void VisitName(DeclarationName Name) override {
-      Hash.AddDeclarationName(Name);
-    }
-    void VisitIdentifierInfo(IdentifierInfo *II) override {
-      ID.AddBoolean(II);
-      if (II) {
-        Hash.AddIdentifierInfo(II);
-      }
-    }
-    void VisitDecl(const Decl *D) override {
-      ID.AddBoolean(D);
-      if (D) {
-        Hash.AddDecl(D);
-      }
-    }
-    void VisitTemplateName(TemplateName Name) override {
-      Hash.AddTemplateName(Name);
-    }
-    void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) override {
-      ID.AddBoolean(NNS);
-      if (NNS) {
-        Hash.AddNestedNameSpecifier(NNS);
-      }
-    }
-  };
 }
 
 void StmtProfiler::VisitStmt(const Stmt *S) {
@@ -979,7 +853,7 @@ void StmtProfiler::VisitOffsetOfExpr(const OffsetOfExpr *S) {
       break;
 
     case OffsetOfNode::Identifier:
-      VisitIdentifierInfo(ON.getFieldName());
+      ID.AddPointer(ON.getFieldName());
       break;
 
     case OffsetOfNode::Base:
@@ -987,7 +861,7 @@ void StmtProfiler::VisitOffsetOfExpr(const OffsetOfExpr *S) {
       break;
     }
   }
-
+  
   VisitExpr(S);
 }
 
@@ -1577,7 +1451,7 @@ StmtProfiler::VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *S) {
   if (S->getDestroyedTypeInfo())
     VisitType(S->getDestroyedType());
   else
-    VisitIdentifierInfo(S->getDestroyedTypeIdentifier());
+    ID.AddPointer(S->getDestroyedTypeIdentifier());
 }
 
 void StmtProfiler::VisitOverloadExpr(const OverloadExpr *S) {
@@ -1827,6 +1701,77 @@ void StmtProfiler::VisitObjCAvailabilityCheckExpr(
   VisitExpr(S);
 }
 
+void StmtProfiler::VisitDecl(const Decl *D) {
+  ID.AddInteger(D? D->getKind() : 0);
+
+  if (Canonical && D) {
+    if (const NonTypeTemplateParmDecl *NTTP =
+          dyn_cast<NonTypeTemplateParmDecl>(D)) {
+      ID.AddInteger(NTTP->getDepth());
+      ID.AddInteger(NTTP->getIndex());
+      ID.AddBoolean(NTTP->isParameterPack());
+      VisitType(NTTP->getType());
+      return;
+    }
+
+    if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) {
+      // The Itanium C++ ABI uses the type, scope depth, and scope
+      // index of a parameter when mangling expressions that involve
+      // function parameters, so we will use the parameter's type for
+      // establishing function parameter identity. That way, our
+      // definition of "equivalent" (per C++ [temp.over.link]) is at
+      // least as strong as the definition of "equivalent" used for
+      // name mangling.
+      VisitType(Parm->getType());
+      ID.AddInteger(Parm->getFunctionScopeDepth());
+      ID.AddInteger(Parm->getFunctionScopeIndex());
+      return;
+    }
+
+    if (const TemplateTypeParmDecl *TTP =
+          dyn_cast<TemplateTypeParmDecl>(D)) {
+      ID.AddInteger(TTP->getDepth());
+      ID.AddInteger(TTP->getIndex());
+      ID.AddBoolean(TTP->isParameterPack());
+      return;
+    }
+
+    if (const TemplateTemplateParmDecl *TTP =
+          dyn_cast<TemplateTemplateParmDecl>(D)) {
+      ID.AddInteger(TTP->getDepth());
+      ID.AddInteger(TTP->getIndex());
+      ID.AddBoolean(TTP->isParameterPack());
+      return;
+    }
+  }
+
+  ID.AddPointer(D? D->getCanonicalDecl() : nullptr);
+}
+
+void StmtProfiler::VisitType(QualType T) {
+  if (Canonical)
+    T = Context.getCanonicalType(T);
+
+  ID.AddPointer(T.getAsOpaquePtr());
+}
+
+void StmtProfiler::VisitName(DeclarationName Name) {
+  ID.AddPointer(Name.getAsOpaquePtr());
+}
+
+void StmtProfiler::VisitNestedNameSpecifier(NestedNameSpecifier *NNS) {
+  if (Canonical)
+    NNS = Context.getCanonicalNestedNameSpecifier(NNS);
+  ID.AddPointer(NNS);
+}
+
+void StmtProfiler::VisitTemplateName(TemplateName Name) {
+  if (Canonical)
+    Name = Context.getCanonicalTemplateName(Name);
+
+  Name.Profile(ID);
+}
+
 void StmtProfiler::VisitTemplateArguments(const TemplateArgumentLoc *Args,
                                           unsigned NumArgs) {
   ID.AddInteger(NumArgs);
@@ -1876,12 +1821,6 @@ void StmtProfiler::VisitTemplateArgument(const TemplateArgument &Arg) {
 
 void Stmt::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    bool Canonical) const {
-  StmtProfilerWithPointers Profiler(ID, Context, Canonical);
-  Profiler.Visit(this);
-}
-
-void Stmt::ProcessODRHash(llvm::FoldingSetNodeID &ID,
-                          class ODRHash &Hash) const {
-  StmtProfilerWithoutPointers Profiler(ID, Hash);
+  StmtProfiler Profiler(ID, Context, Canonical);
   Profiler.Visit(this);
 }