Make all CF types Equatable and Hashable. (#4417)

Like NSObject, CFType has primitive operations CFEqual and CFHash,
so Swift should allow those types to show up in Hashable positions
(like dictionaries). The most general way to do this was to
introduce a new protocol, _CFObject, and then have the importer
automatically make all CF types conform to it.

This did require one additional change: the == implementation that
calls through to CFEqual is in a new CoreFoundation overlay, but the
conformance is in the underlying Clang module. Therefore, operator
lookup for conformances has been changed to look in the overlay for
an imported declaration (if there is one).

https://bugs.swift.org/browse/SR-2388
(cherry picked from commit 361ab62)

Author: jrose-apple

include/swift/AST/KnownIdentifiers.def

@@ -30,6 +30,7 @@ IDENTIFIER(atIndexedSubscript)
 IDENTIFIER_(bridgeToObjectiveC)
 IDENTIFIER_WITH_NAME(code_, "_code")
 IDENTIFIER(CGFloat)
+IDENTIFIER(CoreFoundation)
 IDENTIFIER(CVarArg)
 IDENTIFIER(Darwin)
 IDENTIFIER(dealloc)

include/swift/AST/KnownProtocols.def

@@ -58,12 +58,14 @@ PROTOCOL(Comparable)
 PROTOCOL(Error)
 PROTOCOL_(ErrorCodeProtocol)
 PROTOCOL(OptionSet)
+
 PROTOCOL_(BridgedNSError)
 PROTOCOL_(BridgedStoredNSError)
+PROTOCOL_(CFObject)
+PROTOCOL_(SwiftNewtypeWrapper)
 
 PROTOCOL_(ObjectiveCBridgeable)
 PROTOCOL_(DestructorSafeContainer)
-PROTOCOL_(SwiftNewtypeWrapper)
 
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByArrayLiteral)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByBooleanLiteral)

lib/AST/ASTContext.cpp

@@ -927,23 +927,26 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   // Find all of the declarations with this name in the appropriate module.
   SmallVector<ValueDecl *, 1> results;
 
-  // _BridgedNSError, _BridgedStoredNSError, and _ErrorCodeProtocol
-  // are in the Foundation module.
-  if (kind == KnownProtocolKind::BridgedNSError ||
-      kind == KnownProtocolKind::BridgedStoredNSError ||
-      kind == KnownProtocolKind::ErrorCodeProtocol) {
-    Module *foundation =
-        const_cast<ASTContext *>(this)->getLoadedModule(Id_Foundation);
-    if (!foundation)
-      return nullptr;
-
-    auto identifier = getIdentifier(getProtocolName(kind));
-    foundation->lookupValue({ }, identifier, NLKind::UnqualifiedLookup,
-                            results);
-  } else {
-    lookupInSwiftModule(getProtocolName(kind), results);
+  const Module *M;
+  switch (kind) {
+  case KnownProtocolKind::BridgedNSError:
+  case KnownProtocolKind::BridgedStoredNSError:
+  case KnownProtocolKind::ErrorCodeProtocol:
+    M = getLoadedModule(Id_Foundation);
+    break;
+  case KnownProtocolKind::CFObject:
+    M = getLoadedModule(Id_CoreFoundation);
+    break;
+  default:
+    M = getStdlibModule();
+    break;
   }
 
+  if (!M)
+    return nullptr;
+  M->lookupValue({ }, getIdentifier(getProtocolName(kind)),
+                 NLKind::UnqualifiedLookup, results);
+
   for (auto result : results) {
     if (auto protocol = dyn_cast<ProtocolDecl>(result)) {
       Impl.KnownProtocols[index] = protocol;

lib/ClangImporter/ImportDecl.cpp

@@ -1279,9 +1279,14 @@ namespace {
       addObjCAttribute(theClass, None);
       Impl.registerExternalDecl(theClass);
 
-      SmallVector<ProtocolDecl *, 4> protocols;
-      theClass->getImplicitProtocols(protocols);
-      addObjCProtocolConformances(theClass, protocols);
+      auto *cfObjectProto =
+          Impl.SwiftContext.getProtocol(KnownProtocolKind::CFObject);
+      if (cfObjectProto) {
+        populateInheritedTypes(theClass, cfObjectProto, superclass);
+        auto *attr = new (Impl.SwiftContext) SynthesizedProtocolAttr(
+            KnownProtocolKind::CFObject);
+        theClass->getAttrs().add(attr);
+      }
 
       // Look for bridging attributes on the clang record.  We can
       // just check the most recent redeclaration, which will inherit
@@ -2209,11 +2214,14 @@ namespace {
     }
 
     void populateInheritedTypes(NominalTypeDecl *nominal,
-                                ArrayRef<ProtocolDecl *> protocols) {
+                                ArrayRef<ProtocolDecl *> protocols,
+                                Type superclass = Type()) {
       SmallVector<TypeLoc, 4> inheritedTypes;
-      inheritedTypes.resize(protocols.size());
-      for_each(MutableArrayRef<TypeLoc>(inheritedTypes),
-               ArrayRef<ProtocolDecl *>(protocols),
+      inheritedTypes.resize(protocols.size() + (superclass ? 1 : 0));
+      if (superclass)
+        inheritedTypes[0] = TypeLoc::withoutLoc(superclass);
+      for_each(MutableArrayRef<TypeLoc>(inheritedTypes).slice(superclass?1:0),
+               protocols,
                [](TypeLoc &tl, ProtocolDecl *proto) {
                  tl = TypeLoc::withoutLoc(proto->getDeclaredType());
                });
@@ -4995,7 +5003,7 @@ namespace {
     /// given vector, guarded by the known set of protocols.
     void addProtocols(ProtocolDecl *protocol,
                       SmallVectorImpl<ProtocolDecl *> &protocols,
-                      llvm::SmallPtrSet<ProtocolDecl *, 4> &known) {
+                      llvm::SmallPtrSetImpl<ProtocolDecl *> &known) {
       if (!known.insert(protocol).second)
         return;
 
@@ -5005,6 +5013,13 @@ namespace {
         addProtocols(inherited, protocols, known);
     }
 
+    void addProtocols(ProtocolDecl *protocol,
+                      SmallVectorImpl<ProtocolDecl *> &protocols) {
+      llvm::SmallPtrSet<ProtocolDecl *, 4> known(protocols.begin(),
+                                                 protocols.end());
+      addProtocols(protocol, protocols, known);
+    }
+
     // Import the given Objective-C protocol list, along with any
     // implicitly-provided protocols, and attach them to the given
     // declaration.
@@ -5013,16 +5028,14 @@ namespace {
                              SmallVectorImpl<TypeLoc> &inheritedTypes) {
       SmallVector<ProtocolDecl *, 4> protocols;
       llvm::SmallPtrSet<ProtocolDecl *, 4> knownProtocols;
-      if (auto nominal = dyn_cast<NominalTypeDecl>(decl)) {
+      if (auto nominal = dyn_cast<NominalTypeDecl>(decl))
         nominal->getImplicitProtocols(protocols);
-        knownProtocols.insert(protocols.begin(), protocols.end());
-      }
 
       for (auto cp = clangProtocols.begin(), cpEnd = clangProtocols.end();
            cp != cpEnd; ++cp) {
         if (auto proto = cast_or_null<ProtocolDecl>(Impl.importDecl(*cp,
                                                                     false))) {
-          addProtocols(proto, protocols, knownProtocols);
+          addProtocols(proto, protocols);
           inheritedTypes.push_back(
             TypeLoc::withoutLoc(proto->getDeclaredType()));
         }

lib/IRGen/GenMeta.cpp

@@ -5541,6 +5541,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::OptionSet:
   case KnownProtocolKind::BridgedNSError:
   case KnownProtocolKind::BridgedStoredNSError:
+  case KnownProtocolKind::CFObject:
   case KnownProtocolKind::ErrorCodeProtocol:
     return SpecialProtocol::None;
   }

lib/Sema/TypeCheckProtocol.cpp

@@ -29,6 +29,7 @@
 #include "swift/AST/TypeMatcher.h"
 #include "swift/AST/TypeWalker.h"
 #include "swift/Basic/Defer.h"
+#include "swift/ClangImporter/ClangModule.h"
 #include "swift/Sema/IDETypeChecking.h"
 #include "llvm/ADT/ScopedHashTable.h"
 #include "llvm/ADT/SmallString.h"
@@ -1135,39 +1136,87 @@ bool WitnessChecker::findBestWitness(ValueDecl *requirement,
                                      unsigned &numViable,
                                      unsigned &bestIdx,
                                      bool &doNotDiagnoseMatches) {
-  auto witnesses = lookupValueWitnesses(requirement, ignoringNames);
-
-  // Match each of the witnesses to the requirement.
-  bool anyFromUnconstrainedExtension = false;
-  numViable = 0;
-  bestIdx = 0;
-
-  for (auto witness : witnesses) {
-    // Don't match anything in a protocol.
-    // FIXME: When default implementations come along, we can try to match
-    // these when they're default implementations coming from another
-    // (unrelated) protocol.
-    if (isa<ProtocolDecl>(witness->getDeclContext())) {
-      continue;
-    }
+  enum Attempt {
+    Regular,
+    OperatorsFromOverlay,
+    Done
+  };
 
-    if (!witness->hasType())
-      TC.validateDecl(witness, true);
+  SmallVector<ValueDecl *, 4> witnesses;
+  bool anyFromUnconstrainedExtension;
 
-    auto match = matchWitness(TC, Proto, conformance, DC,
-                              requirement, witness);
-    if (match.isViable()) {
-      ++numViable;
-      bestIdx = matches.size();
-    } else if (match.Kind == MatchKind::WitnessInvalid) {
-      doNotDiagnoseMatches = true;
+  for (Attempt attempt = Regular; attempt != Done;
+       attempt = static_cast<Attempt>(attempt + 1)) {
+    switch (attempt) {
+    case Regular:
+      witnesses = lookupValueWitnesses(requirement, ignoringNames);
+      break;
+    case OperatorsFromOverlay: {
+      // If we have a Clang declaration, the matching operator might be in the
+      // overlay for that module.
+      if (!requirement->isOperator())
+        continue;
+
+      auto *clangModule =
+          dyn_cast<ClangModuleUnit>(DC->getModuleScopeContext());
+      if (!clangModule)
+        continue;
+
+      DeclContext *overlay = clangModule->getAdapterModule();
+      if (!overlay)
+        continue;
+
+      auto lookupOptions = defaultUnqualifiedLookupOptions;
+      lookupOptions |= NameLookupFlags::KnownPrivate;
+      auto lookup = TC.lookupUnqualified(overlay, requirement->getName(),
+                                         SourceLoc(), lookupOptions);
+      witnesses.clear();
+      for (auto candidate : lookup)
+        witnesses.push_back(candidate.Decl);
+      break;
     }
+    case Done:
+      llvm_unreachable("should have exited loop");
+    }
+
+    // Match each of the witnesses to the requirement.
+    anyFromUnconstrainedExtension = false;
+    numViable = 0;
+    bestIdx = 0;
+
+    for (auto witness : witnesses) {
+      // Don't match anything in a protocol.
+      // FIXME: When default implementations come along, we can try to match
+      // these when they're default implementations coming from another
+      // (unrelated) protocol.
+      if (isa<ProtocolDecl>(witness->getDeclContext())) {
+        continue;
+      }
+
+      if (!witness->hasType())
+        TC.validateDecl(witness, true);
 
-    if (auto *ext = dyn_cast<ExtensionDecl>(match.Witness->getDeclContext()))
-      if (!ext->isConstrainedExtension() && ext->getAsProtocolExtensionContext())
-        anyFromUnconstrainedExtension = true;
+      auto match = matchWitness(TC, Proto, conformance, DC,
+                                requirement, witness);
+      if (match.isViable()) {
+        ++numViable;
+        bestIdx = matches.size();
+      } else if (match.Kind == MatchKind::WitnessInvalid) {
+        doNotDiagnoseMatches = true;
+      }
+
+      if (auto *ext = dyn_cast<ExtensionDecl>(match.Witness->getDeclContext())){
+        if (!ext->isConstrainedExtension() &&
+            ext->getAsProtocolExtensionContext()) {
+          anyFromUnconstrainedExtension = true;
+        }
+      }
 
-    matches.push_back(std::move(match));
+      matches.push_back(std::move(match));
+    }
+
+    if (numViable > 0)
+      break;
   }
 
   if (numViable == 0) {

stdlib/public/SDK/CMakeLists.txt

@@ -17,6 +17,7 @@ add_subdirectory(CloudKit)
 add_subdirectory(Contacts)
 add_subdirectory(CoreAudio)
 add_subdirectory(CoreData)
+add_subdirectory(CoreFoundation)
 add_subdirectory(CoreGraphics)
 add_subdirectory(CoreImage)
 add_subdirectory(CoreLocation)

stdlib/public/SDK/CoreAudio/CMakeLists.txt

@@ -3,8 +3,7 @@ add_swift_library(swiftCoreAudio ${SWIFT_SDK_OVERLAY_LIBRARY_BUILD_TYPES} IS_SDK
   ../../../public/core/WriteBackMutableSlice.swift
 
   TARGET_SDKS OSX IOS IOS_SIMULATOR TVOS TVOS_SIMULATOR WATCHOS WATCHOS_SIMULATOR
-  SWIFT_MODULE_DEPENDS Dispatch
+  SWIFT_MODULE_DEPENDS Dispatch CoreFoundation
   SWIFT_MODULE_DEPENDS_OSX IOKit
-  # Also depends on: CoreFoundation
   FRAMEWORK_DEPENDS CoreAudio)
 

stdlib/public/SDK/CoreFoundation/CMakeLists.txt

@@ -0,0 +1,7 @@
+add_swift_library(swiftCoreFoundation ${SWIFT_SDK_OVERLAY_LIBRARY_BUILD_TYPES} IS_SDK_OVERLAY
+  CoreFoundation.swift
+
+  SWIFT_COMPILE_FLAGS "${SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS}"
+  LINK_FLAGS "${SWIFT_RUNTIME_SWIFT_LINK_FLAGS}"
+  SWIFT_MODULE_DEPENDS ObjectiveC Dispatch os
+  FRAMEWORK_DEPENDS CoreFoundation)

stdlib/public/SDK/CoreFoundation/CoreFoundation.swift

@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+@_exported import CoreFoundation
+
+public protocol _CFObject: class, Hashable {}
+extension _CFObject {
+  public var hashValue: Int {
+    return Int(bitPattern: CFHash(self))
+  }
+  public static func ==(left: Self, right: Self) -> Bool {
+    return CFEqual(left, right)
+  }
+}

stdlib/public/SDK/CoreGraphics/CMakeLists.txt

@@ -4,7 +4,7 @@ add_swift_library(swiftCoreGraphics ${SWIFT_SDK_OVERLAY_LIBRARY_BUILD_TYPES} IS_
   Private.swift
   # rdar://problem/20891746
   # SWIFT_COMPILE_FLAGS ${STDLIB_SIL_SERIALIZE_ALL}
-  SWIFT_MODULE_DEPENDS ObjectiveC Dispatch Darwin
+  SWIFT_MODULE_DEPENDS ObjectiveC Dispatch Darwin CoreFoundation
   SWIFT_MODULE_DEPENDS_OSX IOKit XPC
   FRAMEWORK_DEPENDS CoreGraphics)
 

stdlib/public/SDK/CoreGraphics/CoreGraphics.swift

@@ -46,11 +46,6 @@ extension CGColor {
 #endif
 }
 
-extension CGColor: Equatable {}
-public func ==(lhs: CGColor, rhs: CGColor) -> Bool {
-  return lhs.__equalTo(rhs)
-}
-
 
 //===----------------------------------------------------------------------===//
 // CGColorSpace
@@ -471,11 +466,6 @@ extension CGPath {
   }
 }
 
-extension CGPath: Equatable {}
-public func ==(lhs: CGPath, rhs: CGPath) -> Bool {
-  return lhs.__equalTo(rhs)
-}
-
 extension CGMutablePath {
 
   public func addRoundedRect(in rect: CGRect, cornerWidth: CGFloat,

stdlib/public/SDK/Foundation/CMakeLists.txt

@@ -35,7 +35,7 @@ add_swift_library(swiftFoundation ${SWIFT_SDK_OVERLAY_LIBRARY_BUILD_TYPES} IS_SD
   Hashing.m
   Thunks.mm
 
-  SWIFT_MODULE_DEPENDS ObjectiveC CoreGraphics Dispatch os
+  SWIFT_MODULE_DEPENDS ObjectiveC CoreFoundation CoreGraphics Dispatch os
   SWIFT_MODULE_DEPENDS_OSX XPC
   FRAMEWORK_DEPENDS Foundation)
 

stdlib/public/SDK/IOKit/CMakeLists.txt

@@ -1,5 +1,5 @@
 add_swift_library(swiftIOKit ${SWIFT_SDK_OVERLAY_LIBRARY_BUILD_TYPES} IS_SDK_OVERLAY
   IOKit.swift
   TARGET_SDKS OSX
-  SWIFT_MODULE_DEPENDS ObjectiveC Dispatch
+  SWIFT_MODULE_DEPENDS ObjectiveC Dispatch CoreFoundation
   FRAMEWORK_DEPENDS IOKit)

test/ClangModules/Inputs/SwiftPrivateAttr.txt

@@ -95,7 +95,7 @@ struct NSOptions : OptionSet {
   static var __privA: NSOptions { get }
   static var B: NSOptions { get }
 }
-class __PrivCFType {
+class __PrivCFType : _CFObject {
 }
 typealias __PrivCFSub = __PrivCFType
 typealias __PrivInt = Int32