Add general ODR hash support for ObjCInterfaceDecl.

Add ODR diagnostics for mismatches with super classes and number of protocols.
There's still a lot to cover: properties, ivars, methods and other relevant
bits which are going to be added in follow up commits.

rdar://problem/53021360

Author: bcardosolopes

clang/include/clang/AST/DeclObjC.h

@@ -1196,6 +1196,7 @@ class ObjCContainerDecl : public NamedDecl, public DeclContext {
 class ObjCInterfaceDecl : public ObjCContainerDecl
                         , public Redeclarable<ObjCInterfaceDecl> {
   friend class ASTContext;
+  friend class ASTReader;
 
   /// TypeForDecl - This indicates the Type object that represents this
   /// TypeDecl.  It is a cache maintained by ASTContext::getObjCInterfaceType
@@ -1253,6 +1254,12 @@ class ObjCInterfaceDecl : public ObjCContainerDecl
     /// One of the \c InheritedDesignatedInitializersState enumeratos.
     mutable unsigned InheritedDesignatedInitializers : 2;
 
+    /// Tracks whether a ODR hash has been computed for this interface.
+    unsigned HasODRHash : 1;
+
+    /// A hash of parts of the class to help in ODR checking.
+    unsigned ODRHash = 0;
+
     /// The location of the last location in this declaration, before
     /// the properties/methods. For example, this will be the '>', '}', or
     /// identifier,
@@ -1261,7 +1268,7 @@ class ObjCInterfaceDecl : public ObjCContainerDecl
     DefinitionData()
         : ExternallyCompleted(false), IvarListMissingImplementation(true),
           HasDesignatedInitializers(false),
-          InheritedDesignatedInitializers(IDI_Unknown) {}
+          InheritedDesignatedInitializers(IDI_Unknown), HasODRHash(false) {}
   };
 
   /// The type parameters associated with this class, if any.
@@ -1946,7 +1953,14 @@ class ObjCInterfaceDecl : public ObjCContainerDecl
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == ObjCInterface; }
 
+  /// Get precomputed ODRHash or add a new one.
+  unsigned getODRHash();
+
 private:
+  /// True if a valid hash is stored in ODRHash.
+  bool hasODRHash() const;
+  void setHasODRHash(bool Hash = true);
+
   const ObjCInterfaceDecl *findInterfaceWithDesignatedInitializers() const;
   bool inheritsDesignatedInitializers() const;
 };

clang/include/clang/AST/ODRHash.h

@@ -59,6 +59,10 @@ class ODRHash {
   // method compares more information than the AddDecl class.
   void AddRecordDecl(const RecordDecl *Record);
 
+  // Use this for ODR checking ObjC interfaces. This
+  // method compares more information than the AddDecl class.
+  void AddObjCInterfaceDecl(const ObjCInterfaceDecl *Record);
+
   // Use this for ODR checking functions between modules.  This method compares
   // more information than the AddDecl class.  SkipBody will process the
   // hash as if the function has no body.

clang/include/clang/Basic/DiagnosticSerializationKinds.td

@@ -153,6 +153,21 @@ def note_module_odr_violation_definition_data : Note <
   "%ordinal2 base class %3 with "
   "%select{public|protected|private|no}4 access specifier}1">;
 
+def err_module_odr_violation_obj_interface_definition_data : Error <
+  "%q0 has different definitions in different modules; first difference is "
+  "%select{definition in module '%2'|defined here}1 found "
+  "%select{"
+  "%select{no super class|super class with type %5}4|"
+  "%4 referenced %plural{1:protocol|:protocols}4|"
+  "}3">;
+
+def note_module_odr_violation_obj_interface_definition_data : Note <
+  "but in '%0' found "
+  "%select{"
+  "%select{no super class|super class with type %3}2|"
+  "%2 referenced %plural{1:protocol|:protocols}2|"
+  "}1">;
+
 def err_module_odr_violation_template_parameter : Error <
   "%q0 has different definitions in different modules; first difference is "
   "%select{definition in module '%2'|defined here}1 found "

clang/include/clang/Serialization/ASTReader.h

@@ -13,6 +13,7 @@
 #ifndef LLVM_CLANG_SERIALIZATION_ASTREADER_H
 #define LLVM_CLANG_SERIALIZATION_ASTREADER_H
 
+#include "clang/AST/DeclObjC.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
@@ -1087,6 +1088,8 @@ class ASTReader
 
   using DataPointers =
       std::pair<CXXRecordDecl *, struct CXXRecordDecl::DefinitionData *>;
+  using IDDataPointers = std::pair<ObjCInterfaceDecl *,
+                                   struct ObjCInterfaceDecl::DefinitionData *>;
 
   /// Record definitions in which we found an ODR violation.
   llvm::SmallDenseMap<CXXRecordDecl *, llvm::SmallVector<DataPointers, 2>, 2>
@@ -1104,6 +1107,11 @@ class ASTReader
   llvm::SmallDenseMap<RecordDecl *, llvm::SmallVector<RecordDecl *, 2>, 2>
       PendingRecordOdrMergeFailures;
 
+  /// ObjCInterfaceDecl in which we found an ODR violation.
+  llvm::SmallDenseMap<ObjCInterfaceDecl *, llvm::SmallVector<IDDataPointers, 2>,
+                      2>
+      PendingObjCInterfaceOdrMergeFailures;
+
   /// DeclContexts in which we have diagnosed an ODR violation.
   llvm::SmallPtrSet<DeclContext*, 2> DiagnosedOdrMergeFailures;
 

clang/lib/AST/DeclObjC.cpp

@@ -16,6 +16,7 @@
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
+#include "clang/AST/ODRHash.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
@@ -771,6 +772,33 @@ ObjCMethodDecl *ObjCInterfaceDecl::lookupPrivateMethod(
   return Method;
 }
 
+unsigned ObjCInterfaceDecl::getODRHash() {
+  assert(hasDefinition() && "ODRHash only for records with definitions");
+
+  // Previously calculated hash is stored in DefinitionData.
+  if (hasODRHash())
+    return data().ODRHash;
+
+  // Only calculate hash on first call of getODRHash per record.
+  class ODRHash Hash;
+  Hash.AddObjCInterfaceDecl(getDefinition());
+  setHasODRHash();
+  data().ODRHash = Hash.CalculateHash();
+
+  return data().ODRHash;
+}
+
+bool ObjCInterfaceDecl::hasODRHash() const {
+  if (!hasDefinition())
+    return false;
+  return data().HasODRHash;
+}
+
+void ObjCInterfaceDecl::setHasODRHash(bool Hash) {
+  assert(hasDefinition() && "Cannot set ODRHash without definition");
+  data().HasODRHash = Hash;
+}
+
 //===----------------------------------------------------------------------===//
 // ObjCMethodDecl
 //===----------------------------------------------------------------------===//

clang/lib/AST/ODRHash.cpp

@@ -464,6 +464,27 @@ void ODRHash::AddSubDecl(const Decl *D) {
   ODRDeclVisitor(ID, *this).Visit(D);
 }
 
+void ODRHash::AddObjCInterfaceDecl(const ObjCInterfaceDecl *IF) {
+  AddDecl(IF);
+
+  auto *SuperClass = IF->getSuperClass();
+  AddBoolean(SuperClass);
+  if (SuperClass)
+    ID.AddInteger(SuperClass->getODRHash());
+  ID.AddInteger(IF->getReferencedProtocols().size());
+
+  // Filter out sub-Decls which will not be processed in order to get an
+  // accurate count of Decl's.
+  llvm::SmallVector<const Decl *, 16> Decls;
+  for (Decl *SubDecl : IF->decls())
+    if (isWhitelistedDecl(SubDecl, IF))
+      Decls.push_back(SubDecl);
+
+  ID.AddInteger(Decls.size());
+  for (auto *SubDecl : Decls)
+    AddSubDecl(SubDecl);
+}
+
 void ODRHash::AddRecordDecl(const RecordDecl *Record) {
   AddDecl(Record);
 

clang/lib/Serialization/ASTReader.cpp

@@ -9270,7 +9270,8 @@ void ASTReader::diagnoseOdrViolations() {
   if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
       PendingFunctionOdrMergeFailures.empty() &&
       PendingEnumOdrMergeFailures.empty() &&
-      PendingRecordOdrMergeFailures.empty())
+      PendingRecordOdrMergeFailures.empty() &&
+      PendingObjCInterfaceOdrMergeFailures.empty())
     return;
 
   // Trigger the import of the full definition of each class that had any
@@ -9301,6 +9302,16 @@ void ASTReader::diagnoseOdrViolations() {
       D->decls_begin();
   }
 
+  // Trigger the import of the full interface definition.
+  auto ObjCInterfaceOdrMergeFailures =
+      std::move(PendingObjCInterfaceOdrMergeFailures);
+  PendingObjCInterfaceOdrMergeFailures.clear();
+  for (auto &Merge : ObjCInterfaceOdrMergeFailures) {
+    Merge.first->decls_begin();
+    for (auto &InterfacePair : Merge.second)
+      InterfacePair.first->decls_begin();
+  }
+
   // Trigger the import of functions.
   auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
   PendingFunctionOdrMergeFailures.clear();
@@ -9413,7 +9424,8 @@ void ASTReader::diagnoseOdrViolations() {
   }
 
   if (OdrMergeFailures.empty() && FunctionOdrMergeFailures.empty() &&
-      EnumOdrMergeFailures.empty() && RecordOdrMergeFailures.empty())
+      EnumOdrMergeFailures.empty() && RecordOdrMergeFailures.empty() &&
+      ObjCInterfaceOdrMergeFailures.empty())
     return;
 
   // Ensure we don't accidentally recursively enter deserialization while
@@ -11199,6 +11211,172 @@ void ASTReader::diagnoseOdrViolations() {
     }
   }
 
+  for (auto &Merge : ObjCInterfaceOdrMergeFailures) {
+    // If we've already pointed out a specific problem with this interface,
+    // don't bother issuing a general "something's different" diagnostic.
+    if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
+      continue;
+
+    bool Diagnosed = false;
+    ObjCInterfaceDecl *FirstID = Merge.first;
+    std::string FirstModule = getOwningModuleNameForDiagnostic(FirstID);
+    for (auto &InterfacePair : Merge.second) {
+      ObjCInterfaceDecl *SecondID = InterfacePair.first;
+      // Multiple different declarations got merged together; tell the user
+      // where they came from.
+      if (FirstID == SecondID)
+        continue;
+
+      std::string SecondModule = getOwningModuleNameForDiagnostic(SecondID);
+
+      auto *FirstDD = &FirstID->data();
+      auto *SecondDD = InterfacePair.second;
+      assert(FirstDD && SecondDD && "Definitions without DefinitionData");
+      // Diagnostics from ObjCInterfaces DefinitionData are emitted here.
+      // FIXME: as part of definition data handling, add support for checking
+      // matching protocols, ivars and categories
+      if (FirstDD != SecondDD) {
+        // Keep this in sync with
+        // err_module_odr_violation_obj_interface_definition_data and
+        // note_module_odr_violation_obj_interface_definition_data.
+        enum ODRDefinitionDataDifference {
+          SuperClassType,
+          ReferencedProtocols
+        };
+        auto ODRDiagBaseError = [FirstID, &FirstModule,
+                                 this](SourceLocation Loc, SourceRange Range,
+                                       ODRDefinitionDataDifference DiffType) {
+          using namespace diag;
+          return Diag(Loc,
+                      err_module_odr_violation_obj_interface_definition_data)
+                 << FirstID << FirstModule.empty() << FirstModule << Range
+                 << DiffType;
+        };
+        auto ODRDiagBaseNote = [&SecondModule,
+                                this](SourceLocation Loc, SourceRange Range,
+                                      ODRDefinitionDataDifference DiffType) {
+          using namespace diag;
+          return Diag(Loc,
+                      note_module_odr_violation_obj_interface_definition_data)
+                 << SecondModule << Range << DiffType;
+        };
+
+        // Check for matching super class.
+        auto GetSuperClassSourceRange = [](TypeSourceInfo *SuperInfo,
+                                           ObjCInterfaceDecl *ID) {
+          if (!SuperInfo)
+            return ID->getSourceRange();
+          TypeLoc Loc = SuperInfo->getTypeLoc();
+          return SourceRange(Loc.getBeginLoc(), Loc.getEndLoc());
+        };
+
+        ObjCInterfaceDecl *FirstSuperClass = FirstID->getSuperClass();
+        ObjCInterfaceDecl *SecondSuperClass = nullptr;
+        auto *FirstSuperInfo = FirstID->getSuperClassTInfo();
+        auto *SecondSuperInfo = SecondDD->SuperClassTInfo;
+        if (SecondSuperInfo)
+          SecondSuperClass = SecondSuperInfo->getType()
+                                 ->castAs<ObjCObjectType>()
+                                 ->getInterface();
+
+        if ((FirstSuperClass && SecondSuperClass &&
+             FirstSuperClass->getODRHash() != SecondSuperClass->getODRHash()) ||
+            (FirstSuperClass && !SecondSuperClass) ||
+            (!FirstSuperClass && SecondSuperClass)) {
+          QualType FirstType;
+          if (FirstSuperInfo)
+            FirstType = FirstSuperInfo->getType();
+
+          ODRDiagBaseError(FirstID->getLocation(),
+                           GetSuperClassSourceRange(FirstSuperInfo, FirstID),
+                           SuperClassType)
+              << (bool)FirstSuperInfo << FirstType;
+
+          QualType SecondType;
+          if (SecondSuperInfo)
+            SecondType = SecondSuperInfo->getType();
+
+          ODRDiagBaseNote(SecondID->getLocation(),
+                          GetSuperClassSourceRange(SecondSuperInfo, SecondID),
+                          SuperClassType)
+              << (bool)SecondSuperInfo << SecondType;
+          Diagnosed = true;
+          break;
+        }
+
+        // Check both interfaces reference the same number of protocols.
+        // FIXME: add support for checking the actual protocols once support
+        // for ODR hash in protocols land.
+        auto GetProtoListSourceRange = [](ObjCInterfaceDecl *ID,
+                                          const ObjCProtocolList &PL) {
+          if (!PL.size())
+            return ID->getSourceRange();
+          return SourceRange(*PL.loc_begin(), *std::prev(PL.loc_end()));
+        };
+        auto &FirstProtos = FirstID->getReferencedProtocols();
+        auto &SecondProtos = SecondDD->ReferencedProtocols;
+        if (FirstProtos.size() != SecondProtos.size()) {
+          ODRDiagBaseError(FirstID->getLocation(),
+                           GetProtoListSourceRange(FirstID, FirstProtos),
+                           ReferencedProtocols)
+              << FirstProtos.size();
+          ODRDiagBaseNote(SecondID->getLocation(),
+                          GetProtoListSourceRange(SecondID, SecondProtos),
+                          ReferencedProtocols)
+              << SecondProtos.size();
+          Diagnosed = true;
+          break;
+        }
+      }
+
+      // FIXME: Improve PopulateHashes above and only have one version.
+      auto PopulateHashes = [&ComputeSubDeclODRHash](DeclHashes &Hashes,
+                                                     ObjCInterfaceDecl *ID,
+                                                     const DeclContext *DC) {
+        for (auto *D : ID->decls()) {
+          if (!ODRHash::isWhitelistedDecl(D, DC))
+            continue;
+          Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
+        }
+      };
+
+      DeclHashes FirstHashes;
+      DeclHashes SecondHashes;
+      PopulateHashes(FirstHashes, FirstID, FirstID);
+      PopulateHashes(SecondHashes, SecondID, SecondID);
+
+      auto DR = FindTypeDiffs(FirstHashes, SecondHashes);
+      ODRMismatchDecl FirstDiffType = DR.FirstDiffType;
+      ODRMismatchDecl SecondDiffType = DR.SecondDiffType;
+      Decl *FirstDecl = DR.FirstDecl;
+      Decl *SecondDecl = DR.SecondDecl;
+
+      if (FirstDiffType == Other || SecondDiffType == Other) {
+        DiagnoseODRUnexpected(DR, FirstID, FirstModule, SecondID, SecondModule);
+        Diagnosed = true;
+        break;
+      }
+
+      if (FirstDiffType != SecondDiffType) {
+        DiagnoseODRMismatch(DR, FirstID, FirstModule, SecondID, SecondModule);
+        Diagnosed = true;
+        break;
+      }
+
+      if (Diagnosed)
+        continue;
+
+      Diag(FirstDecl->getLocation(),
+           diag::err_module_odr_violation_mismatch_decl_unknown)
+          << FirstID << FirstModule.empty() << FirstModule << FirstDiffType
+          << FirstDecl->getSourceRange();
+      Diag(SecondDecl->getLocation(),
+           diag::note_module_odr_violation_mismatch_decl_unknown)
+          << SecondModule << FirstDiffType << SecondDecl->getSourceRange();
+      Diagnosed = true;
+    }
+  }
+
   // Issue ODR failures diagnostics for functions.
   for (auto &Merge : FunctionOdrMergeFailures) {
     enum ODRFunctionDifference {