---

yaml
---
r: 243167
b: refs/heads/swift-5.0-branch
c: edb8a73
h: refs/heads/master
i:
  243165: 4869b4c
  243163: d631611
  243159: f95feb2
  243151: 57ba260
  243135: 246bcdc

Author: lorentey

[refs]

@@ -643,7 +643,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2017-12-23-a: b7c074342459a645779f106c42bf4
 refs/heads/master-llvm-swift5-transition: 8ace18c8953afb3d7d94cf04cacc0b51a7e5f1e3
 "refs/heads/revert-12883-disable_modelio_test_ios": a77ae373b809a0d8cb460cf3d1585d618510d242
 refs/heads/revert-13597-master: cccee1df039d072215f9bddc2cbc1e32a8d5d5ee
-refs/heads/swift-5.0-branch: b95ba2507df833f8e172802f8057c0c5f5379288
+refs/heads/swift-5.0-branch: edb8a73203f08d2ceadf29bcd851b02bb8748f94
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2017-12-23-a: b32214f7e04339dfada623b6b76dbebfb41e4541
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2017-12-24-a: 1eb0be506c0744c7eff0550a10240286046e181d
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2017-12-25-a: f35a91502bad0065c83d8760407c23be7b899f48

branches/swift-5.0-branch/stdlib/public/SwiftShims/GlobalObjects.h

@@ -60,23 +60,23 @@ struct _SwiftSetBodyStorage {
   void *keys;
 };
 
-struct _SwiftEmptyDictionaryStorage {
+struct _SwiftEmptyDictionarySingleton {
   struct HeapObject header;
   struct _SwiftDictionaryBodyStorage body;
   __swift_uintptr_t entries;
 };
 
-struct _SwiftEmptySetStorage {
+struct _SwiftEmptySetSingleton {
   struct HeapObject header;
   struct _SwiftSetBodyStorage body;
   __swift_uintptr_t entries;
 };
 
 SWIFT_RUNTIME_STDLIB_API
-struct _SwiftEmptyDictionaryStorage _swiftEmptyDictionaryStorage;
+struct _SwiftEmptyDictionarySingleton _swiftEmptyDictionarySingleton;
 
 SWIFT_RUNTIME_STDLIB_API
-struct _SwiftEmptySetStorage _swiftEmptySetStorage;
+struct _SwiftEmptySetSingleton _swiftEmptySetSingleton;
 
 struct _SwiftHashingParameters {
   __swift_uint64_t seed0;
@@ -91,9 +91,9 @@ struct _SwiftHashingParameters _swift_stdlib_Hashing_parameters;
 
 static_assert(std::is_pod<_SwiftEmptyArrayStorage>::value,
               "empty array type should be POD");
-static_assert(std::is_pod<_SwiftEmptyDictionaryStorage>::value,
+static_assert(std::is_pod<_SwiftEmptyDictionarySingleton>::value,
               "empty dictionary type should be POD");
-static_assert(std::is_pod<_SwiftEmptySetStorage>::value,
+static_assert(std::is_pod<_SwiftEmptySetSingleton>::value,
               "empty set type should be POD");
 
 }} // extern "C", namespace swift

branches/swift-5.0-branch/stdlib/public/core/Dictionary.swift

@@ -1807,14 +1807,13 @@ internal protocol _DictionaryBuffer {
 @_fixed_layout // FIXME(sil-serialize-all)
 @usableFromInline
 @_objc_non_lazy_realization
-internal class _RawNativeDictionaryStorage
-  : _SwiftNativeNSDictionary, _NSDictionaryCore
-{
+internal class _RawNativeDictionaryStorage: _SwiftNativeNSDictionary {
   @usableFromInline // FIXME(sil-serialize-all)
   @nonobjc
   internal final var bucketCount: Int
 
   @usableFromInline // FIXME(sil-serialize-all)
+  @objc
   internal final var count: Int
 
   @usableFromInline // FIXME(sil-serialize-all)
@@ -1838,36 +1837,36 @@ internal class _RawNativeDictionaryStorage
     return UnsafeMutablePointer(Builtin.projectTailElems(self, UInt.self))
   }
 
-  /// The empty singleton that is used for every single Dictionary that is
-  /// created without any elements. The contents of the storage should never
-  /// be mutated.
-  @inlinable
-  @nonobjc
-  internal static var empty: _RawNativeDictionaryStorage {
-    return Builtin.bridgeFromRawPointer(
-      Builtin.addressof(&_swiftEmptyDictionaryStorage))
-  }
-
   // This type is made with allocWithTailElems, so no init is ever called.
   // But we still need to have an init to satisfy the compiler.
   @nonobjc
   internal init(_doNotCallMe: ()) {
     _sanityCheckFailure("Only create this by using the `empty` singleton")
   }
+}
 
-#if _runtime(_ObjC)
-  //
-  // NSDictionary implementation, assuming Self is the empty singleton
-  //
+/// The storage class for the singleton empty set.
+/// The single instance of this class is created by the runtime.
+@_fixed_layout
+@usableFromInline
+internal class _EmptyDictionarySingleton
+  : _RawNativeDictionaryStorage, _NSDictionaryCore {
+  @nonobjc
+  internal override init(_doNotCallMe: ()) {
+    _sanityCheckFailure("Only create this by using the `empty` singleton")
+  }
 
-  /// Get the NSEnumerator implementation for self.
-  /// _HashableTypedNativeDictionaryStorage overloads this to give
-  /// _NativeSelfNSEnumerator proper type parameters.
+#if _runtime(_ObjC)
   @objc
-  internal func enumerator() -> _NSEnumerator {
-    return _SwiftDictionaryNSEnumerator<AnyObject, AnyObject>(
-        _NativeDictionary(_storage: self))
+  internal required init(objects: UnsafePointer<AnyObject?>, count: Int) {
+    _sanityCheckFailure("Don't call this designated initializer")
   }
+#endif
+
+#if _runtime(_ObjC)
+  //
+  // NSDictionary implementation
+  //
 
   @objc(copyWithZone:)
   internal func copy(with zone: _SwiftNSZone?) -> AnyObject {
@@ -1907,8 +1906,9 @@ internal class _RawNativeDictionaryStorage
     return nil
   }
 
+  @objc(keyEnumerator)
   internal func keyEnumerator() -> _NSEnumerator {
-    return enumerator()
+    return _SwiftEmptyNSEnumerator()
   }
 
   @objc(getObjects:andKeys:count:)
@@ -1921,6 +1921,19 @@ internal class _RawNativeDictionaryStorage
 #endif
 }
 
+
+extension _RawNativeDictionaryStorage {
+  /// The empty singleton that is used for every single Dictionary that is
+  /// created without any elements. The contents of the storage should never
+  /// be mutated.
+  @inlinable
+  @nonobjc
+  internal static var empty: _EmptyDictionarySingleton {
+    return Builtin.bridgeFromRawPointer(
+      Builtin.addressof(&_swiftEmptyDictionarySingleton))
+  }
+}
+
 // See the docs at the top of this file for a description of this type
 @_fixed_layout // FIXME(sil-serialize-all)
 @usableFromInline
@@ -1972,7 +1985,7 @@ internal class _TypedNativeDictionaryStorage<Key, Value>
 @_fixed_layout // FIXME(sil-serialize-all)
 @usableFromInline
 final internal class _HashableTypedNativeDictionaryStorage<Key: Hashable, Value>
-  : _TypedNativeDictionaryStorage<Key, Value> {
+  : _TypedNativeDictionaryStorage<Key, Value>, _NSDictionaryCore {
   // This type is made with allocWithTailElems, so no init is ever called.
   // But we still need to have an init to satisfy the compiler.
   @nonobjc
@@ -1990,14 +2003,19 @@ final internal class _HashableTypedNativeDictionaryStorage<Key: Hashable, Value>
     return _NativeDictionary(_storage: self)
   }
 
-  @objc
-  internal override func enumerator() -> _NSEnumerator {
+  @objc(keyEnumerator)
+  internal func keyEnumerator() -> _NSEnumerator {
     return _SwiftDictionaryNSEnumerator<Key, Value>(
         _NativeDictionary(_storage: self))
   }
 
+  @objc(copyWithZone:)
+  internal func copy(with zone: _SwiftNSZone?) -> AnyObject {
+    return self
+  }
+
   @objc(countByEnumeratingWithState:objects:count:)
-  internal override func countByEnumerating(
+  internal func countByEnumerating(
     with state: UnsafeMutablePointer<_SwiftNSFastEnumerationState>,
     objects: UnsafeMutablePointer<AnyObject>?, count: Int
   ) -> Int {
@@ -2059,13 +2077,13 @@ final internal class _HashableTypedNativeDictionaryStorage<Key: Hashable, Value>
   }
 
   @objc(objectForKey:)
-  override func objectFor(_ aKey: AnyObject) -> AnyObject? {
+  func objectFor(_ aKey: AnyObject) -> AnyObject? {
     return getObjectFor(aKey)
   }
 
   // We also override the following methods for efficiency.
   @objc(getObjects:andKeys:count:)
-  override func getObjects(
+  func getObjects(
     _ objects: UnsafeMutablePointer<AnyObject>?,
     andKeys keys: UnsafeMutablePointer<AnyObject>?,
     count: Int) {
@@ -2414,20 +2432,23 @@ extension _NativeDictionary where Key: Hashable {
     // or if we're the empty singleton.
 
     // Temporary var for SOME type safety before a cast.
-    let nsSet: _NSDictionaryCore
-
-    if (_isBridgedVerbatimToObjectiveC(Key.self) &&
-        _isBridgedVerbatimToObjectiveC(Value.self)) ||
-        self._storage === _RawNativeDictionaryStorage.empty {
-      nsSet = self._storage
+    let nsDictionary: _NSDictionaryCore
+
+    if _storage === _RawNativeDictionaryStorage.empty {
+      nsDictionary = _RawNativeDictionaryStorage.empty
+    } else  if _isBridgedVerbatimToObjectiveC(Key.self),
+      _isBridgedVerbatimToObjectiveC(Value.self) {
+      nsDictionary = unsafeDowncast(
+        _storage,
+        to: _HashableTypedNativeDictionaryStorage<Key, Value>.self)
     } else {
-      nsSet = _SwiftDeferredNSDictionary(self)
+      nsDictionary = _SwiftDeferredNSDictionary(self)
     }
 
     // Cast from "minimal NSDictionary" to "NSDictionary"
     // Note that if you actually ask Swift for this cast, it will fail.
     // Never trust a shadow protocol!
-    return unsafeBitCast(nsSet, to: _NSDictionary.self)
+    return unsafeBitCast(nsDictionary, to: _NSDictionary.self)
   }
 #endif
 

branches/swift-5.0-branch/stdlib/public/core/Hashing.swift

@@ -67,3 +67,35 @@ internal struct _UnmanagedAnyObjectArray {
     }
   }
 }
+
+#if _runtime(_ObjC)
+/// An NSEnumerator implementation returning zero elements. This is useful when
+/// a concrete element type is not recoverable from the empty singleton.
+final internal class _SwiftEmptyNSEnumerator
+  : _SwiftNativeNSEnumerator, _NSEnumerator {
+  internal override required init() {}
+
+  @objc
+  internal func nextObject() -> AnyObject? {
+    return nil
+  }
+
+  @objc(countByEnumeratingWithState:objects:count:)
+  internal func countByEnumerating(
+    with state: UnsafeMutablePointer<_SwiftNSFastEnumerationState>,
+    objects: UnsafeMutablePointer<AnyObject>,
+    count: Int
+  ) -> Int {
+    // Even though we never do anything in here, we need to update the
+    // state so that callers know we actually ran.
+    var theState = state.pointee
+    if theState.state == 0 {
+      theState.state = 1 // Arbitrary non-zero value.
+      theState.itemsPtr = AutoreleasingUnsafeMutablePointer(objects)
+      theState.mutationsPtr = _fastEnumerationStorageMutationsPtr
+    }
+    state.pointee = theState
+    return 0
+  }
+}
+#endif