[NFC] Make ObjCMethodConflicts a set

This allows us to stop using `vec.size() == 1` to prevent duplicate conflicts from being diagnosed, which will become untenable in the next commit.

Author: beccadax

include/swift/AST/SourceFile.h

@@ -17,6 +17,7 @@
 #include "swift/AST/Import.h"
 #include "swift/AST/SynthesizedFileUnit.h"
 #include "swift/Basic/Debug.h"
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 
@@ -243,11 +244,20 @@ class SourceFile final : public FileUnit {
   std::vector<ObjCUnsatisfiedOptReq> ObjCUnsatisfiedOptReqs;
 
   /// A selector that is used by two different declarations in the same class.
-  /// Fields: typeDecl, selector, isInstanceMethod.
-  using ObjCMethodConflict = std::tuple<NominalTypeDecl *, ObjCSelector, bool>;
+  struct ObjCMethodConflict {
+    NominalTypeDecl *typeDecl;
+    ObjCSelector selector;
+    bool isInstanceMethod;
+
+    ObjCMethodConflict(NominalTypeDecl *typeDecl, ObjCSelector selector,
+                       bool isInstanceMethod)
+        : typeDecl(typeDecl), selector(selector),
+          isInstanceMethod(isInstanceMethod)
+    {}
+  };
 
   /// List of Objective-C member conflicts we have found during type checking.
-  std::vector<ObjCMethodConflict> ObjCMethodConflicts;
+  llvm::SetVector<ObjCMethodConflict> ObjCMethodConflicts;
 
   /// List of attributes added by access notes, used to emit remarks for valid
   /// ones.
@@ -636,4 +646,30 @@ inline void simple_display(llvm::raw_ostream &out, const SourceFile *SF) {
 }
 } // end namespace swift
 
+namespace llvm {
+
+template<>
+struct DenseMapInfo<swift::SourceFile::ObjCMethodConflict> {
+  using ObjCMethodConflict = swift::SourceFile::ObjCMethodConflict;
+
+  static inline ObjCMethodConflict getEmptyKey() {
+    return ObjCMethodConflict(nullptr, {}, false);
+  }
+  static inline ObjCMethodConflict getTombstoneKey() {
+    return ObjCMethodConflict(nullptr, {}, true);
+  }
+  static inline unsigned getHashValue(ObjCMethodConflict a) {
+    return hash_combine(hash_value(a.typeDecl),
+                  DenseMapInfo<swift::ObjCSelector>::getHashValue(a.selector),
+                  hash_value(a.isInstanceMethod));
+  }
+  static bool isEqual(ObjCMethodConflict a, ObjCMethodConflict b) {
+    return a.typeDecl == b.typeDecl && a.selector == b.selector &&
+           a.isInstanceMethod == b.isInstanceMethod;
+  }
+};
+
+}
+
+
 #endif

lib/AST/NameLookup.cpp

@@ -1714,12 +1714,11 @@ void NominalTypeDecl::recordObjCMethod(AbstractFunctionDecl *method,
     return;
 
   if (auto *sf = method->getParentSourceFile()) {
-    if (vec.size() == 1) {
-      // We have a conflict.
-      sf->ObjCMethodConflicts.push_back(std::make_tuple(this, selector,
-                                                        isInstanceMethod));
-    } if (vec.empty()) {
+    if (vec.empty()) {
       sf->ObjCMethodList.push_back(method);
+    } else {
+      // We have a conflict.
+      sf->ObjCMethodConflicts.insert({ this, selector, isInstanceMethod });
     }
   }
 

lib/Sema/TypeCheckDeclObjC.cpp

@@ -2422,11 +2422,8 @@ bool swift::diagnoseUnintendedObjCMethodOverrides(SourceFile &sf) {
 /// Retrieve the source file for the given Objective-C member conflict.
 static TinyPtrVector<AbstractFunctionDecl *>
 getObjCMethodConflictDecls(const SourceFile::ObjCMethodConflict &conflict) {
-  NominalTypeDecl *typeDecl = std::get<0>(conflict);
-  ObjCSelector selector = std::get<1>(conflict);
-  bool isInstanceMethod = std::get<2>(conflict);
-
-  return typeDecl->lookupDirect(selector, isInstanceMethod);
+  return conflict.typeDecl->lookupDirect(conflict.selector,
+                                         conflict.isInstanceMethod);
 }
 
 static ObjCAttr *getObjCAttrIfFromAccessNote(ValueDecl *VD) {
@@ -2452,7 +2449,8 @@ bool swift::diagnoseObjCMethodConflicts(SourceFile &sf) {
   // Sort the set of conflicts so we get a deterministic order for
   // diagnostics. We use the first conflicting declaration in each set to
   // perform the sort.
-  auto localConflicts = sf.ObjCMethodConflicts;
+  llvm::SmallVector<SourceFile::ObjCMethodConflict, 4> localConflicts;
+  llvm::copy(sf.ObjCMethodConflicts, std::back_inserter(localConflicts));
   std::sort(localConflicts.begin(), localConflicts.end(),
             [&](const SourceFile::ObjCMethodConflict &lhs,
                 const SourceFile::ObjCMethodConflict &rhs) {
@@ -2463,9 +2461,6 @@ bool swift::diagnoseObjCMethodConflicts(SourceFile &sf) {
   // Diagnose each conflict.
   bool anyConflicts = false;
   for (const auto &conflict : localConflicts) {
-    NominalTypeDecl *tyDecl = std::get<0>(conflict);
-    ObjCSelector selector = std::get<1>(conflict);
-
     auto methods = getObjCMethodConflictDecls(conflict);
 
     // Erase any invalid or stub declarations. We don't want to complain about
@@ -2545,10 +2540,10 @@ bool swift::diagnoseObjCMethodConflicts(SourceFile &sf) {
                                                 : diag::objc_redecl,
                                      diagInfo.first, diagInfo.second,
                                      origDiagInfo.first, origDiagInfo.second,
-                                     selector);
+                                     conflict.selector);
 
       // Protocols weren't checked for selector conflicts in 5.0.
-      diag.warnUntilSwiftVersionIf(!isa<ClassDecl>(tyDecl), 6);
+      diag.warnUntilSwiftVersionIf(!isa<ClassDecl>(conflict.typeDecl), 6);
 
       auto objcAttr = getObjCAttrIfFromAccessNote(conflictingDecl);
       swift::softenIfAccessNote(conflictingDecl, objcAttr, diag);