Merge pull request #70217 from kubamracek/embedded-set

[embedded] Add Set to the embedded stdlib

Author: kubamracek

stdlib/public/core/BridgeStorage.swift

@@ -20,6 +20,8 @@
 //===----------------------------------------------------------------------===//
 import SwiftShims
 
+#if !$Embedded
+
 @frozen
 @usableFromInline
 internal struct _BridgeStorage<NativeClass: AnyObject> {
@@ -159,3 +161,77 @@ internal struct _BridgeStorage<NativeClass: AnyObject> {
     }
   }
 }
+
+#else
+
+@frozen
+@usableFromInline
+internal struct _BridgeStorage<NativeClass: AnyObject> {
+  @usableFromInline
+  internal typealias Native = NativeClass
+
+  // rawValue is passed inout to _isUnique.  Although its value
+  // is unchanged, it must appear mutable to the optimizer.
+  @usableFromInline
+  internal var rawValue: NativeClass
+
+  @inlinable
+  @inline(__always)
+  internal init(native: Native) {
+    _internalInvariant(_usesNativeSwiftReferenceCounting(NativeClass.self))
+    rawValue = native
+  }
+
+  @inlinable
+  @inline(__always)
+  internal mutating func isUniquelyReferencedNative() -> Bool {
+    return _isUnique(&rawValue)
+  }
+
+  @_alwaysEmitIntoClient
+  @inline(__always)
+  internal mutating func beginCOWMutationNative() -> Bool {
+    return Bool(Builtin.beginCOWMutation(&rawValue))
+  }
+
+  @inlinable
+  static var flagMask: UInt {
+    @inline(__always) get {
+      return (1 as UInt) << _objectPointerLowSpareBitShift
+    }
+  }
+
+  @inlinable
+  internal var nativeInstance: Native {
+    @inline(__always) get {
+      return rawValue
+    }
+  }
+
+  @inlinable
+  internal var unflaggedNativeInstance: Native {
+    @inline(__always) get {
+      return rawValue
+    }
+  }
+
+  @inlinable
+  @inline(__always)
+  internal mutating func isUniquelyReferencedUnflaggedNative() -> Bool {
+    return _isUnique_native(&rawValue)
+  }
+
+  @_alwaysEmitIntoClient
+  @inline(__always)
+  internal mutating func beginCOWMutationUnflaggedNative() -> Bool {
+    return Bool(Builtin.beginCOWMutation_native(&rawValue))
+  }
+
+  @_alwaysEmitIntoClient
+  @inline(__always)
+  internal mutating func endCOWMutation() {
+    Builtin.endCOWMutation(&rawValue)
+  }
+}
+
+#endif

stdlib/public/core/Builtin.swift

@@ -725,9 +725,11 @@ func _isUnique_native<T>(_ object: inout T) -> Bool {
   // This could be a bridge object, single payload enum, or plain old
   // reference. Any case it's non pointer bits must be zero, so
   // force cast it to BridgeObject and check the spare bits.
+  #if !$Embedded
   _internalInvariant(
     (_bitPattern(Builtin.reinterpretCast(object)) & _objectPointerSpareBits)
     == 0)
+  #endif
   _internalInvariant(_usesNativeSwiftReferenceCounting(
       type(of: Builtin.reinterpretCast(object) as AnyObject)))
   return Bool(Builtin.isUnique_native(&object))

stdlib/public/core/CMakeLists.txt

@@ -43,10 +43,10 @@ split_embedded_sources(
   EMBEDDED Assert.swift
   EMBEDDED AssertCommon.swift
   EMBEDDED BidirectionalCollection.swift
-    NORMAL Bitset.swift
+  EMBEDDED Bitset.swift
   EMBEDDED Bool.swift
     NORMAL BridgeObjectiveC.swift
-    NORMAL BridgeStorage.swift
+  EMBEDDED BridgeStorage.swift
     NORMAL BridgingBuffer.swift
   EMBEDDED Builtin.swift
   EMBEDDED BuiltinMath.swift
@@ -89,7 +89,7 @@ split_embedded_sources(
   # END WORKAROUND
   EMBEDDED Hasher.swift
     NORMAL Hashing.swift
-    NORMAL HashTable.swift
+  EMBEDDED HashTable.swift
   EMBEDDED Identifiable.swift
   EMBEDDED Indices.swift
     NORMAL InputStream.swift
@@ -111,7 +111,7 @@ split_embedded_sources(
   EMBEDDED Misc.swift
   EMBEDDED MutableCollection.swift
     NORMAL NativeDictionary.swift
-    NORMAL NativeSet.swift
+  EMBEDDED NativeSet.swift
     NORMAL NewtypeWrapper.swift
     NORMAL NFC.swift
     NORMAL NFD.swift
@@ -139,15 +139,15 @@ split_embedded_sources(
   EMBEDDED SipHash.swift
   EMBEDDED Sequence.swift
   EMBEDDED SequenceAlgorithms.swift
-    NORMAL Set.swift
+  EMBEDDED Set.swift
   EMBEDDED SetAlgebra.swift
     NORMAL SetAnyHashableExtensions.swift
     NORMAL SetBridging.swift
-    NORMAL SetBuilder.swift
-    NORMAL SetCasting.swift
-    NORMAL SetStorage.swift
-    NORMAL SetVariant.swift
-    NORMAL ShadowProtocols.swift
+  EMBEDDED SetBuilder.swift
+  EMBEDDED SetCasting.swift
+  EMBEDDED SetStorage.swift
+  EMBEDDED SetVariant.swift
+  EMBEDDED ShadowProtocols.swift
     NORMAL Shims.swift
   EMBEDDED Slice.swift
     NORMAL SmallString.swift

stdlib/public/core/ContiguousArrayBuffer.swift

@@ -64,6 +64,12 @@ internal final class __EmptyArrayStorage
 }
 
 #if $Embedded
+// In embedded Swift, the stdlib is a .swiftmodule only without any .o/.a files,
+// to allow consuming it by clients with different LLVM codegen setting (-mcpu
+// flags, etc.), which means we cannot declare the singleton in a C/C++ file.
+//
+// TODO: We should figure out how to make this a constant so that it's placed in
+// non-writable memory (can't be a let, Builtin.addressof below requires a var).
 public var _swiftEmptyArrayStorage: (Int, Int, Int, Int) =
     (/*isa*/0, /*refcount*/-1, /*count*/0, /*flags*/1)
 #endif

stdlib/public/core/DictionaryStorage.swift

@@ -473,7 +473,7 @@ extension _DictionaryStorage {
         truncatingIfNeeded: ObjectIdentifier(storage).hashValue)
     }
 
-    storage._seed = seed ?? _HashTable.hashSeed(for: storage, scale: scale)
+    storage._seed = seed ?? _HashTable.hashSeed(for: Builtin.castToNativeObject(storage), scale: scale)
     storage._rawKeys = UnsafeMutableRawPointer(keysAddr)
     storage._rawValues = UnsafeMutableRawPointer(valuesAddr)
 

stdlib/public/core/EmbeddedRuntime.swift

@@ -275,3 +275,9 @@ public func swift_deletedMethodError() -> Never {
 public func swift_willThrow() throws {
 }
 
+@_extern(c, "arc4random_buf")
+func arc4random_buf(buf: UnsafeMutableRawPointer, nbytes: Int)
+
+public func swift_stdlib_random(_ buf: UnsafeMutableRawPointer, _ nbytes: Int) {
+  arc4random_buf(buf: buf, nbytes: nbytes)
+}

stdlib/public/core/HashTable.swift

@@ -102,7 +102,7 @@ extension _HashTable {
   }
 
   internal static func hashSeed(
-    for object: AnyObject,
+    for object: Builtin.NativeObject,
     scale: Int8
   ) -> Int {
     // We generate a new hash seed whenever a new hash table is allocated and

stdlib/public/core/Hasher.swift

@@ -251,6 +251,16 @@ extension Hasher {
   }
 }
 
+#if $Embedded
+@usableFromInline
+var _swift_stdlib_Hashing_parameters: _SwiftHashingParameters = {
+  var seed0: UInt64 = 0, seed1: UInt64 = 0
+  swift_stdlib_random(&seed0, MemoryLayout<UInt64>.size)
+  swift_stdlib_random(&seed1, MemoryLayout<UInt64>.size)
+  return .init(seed0: seed0, seed1: seed1, deterministic: false)
+}()
+#endif
+
 /// The universal hash function used by `Set` and `Dictionary`.
 ///
 /// `Hasher` can be used to map an arbitrary sequence of bytes to an integer

stdlib/public/core/NativeSet.swift

@@ -351,6 +351,7 @@ extension _NativeSet: _SetBuffer {
 // This function has a highly visible name to make it stand out in stack traces.
 @usableFromInline
 @inline(never)
+@_unavailableInEmbedded
 internal func ELEMENT_TYPE_OF_SET_VIOLATES_HASHABLE_REQUIREMENTS(
   _ elementType: Any.Type
 ) -> Never {
@@ -379,7 +380,11 @@ extension _NativeSet { // Insertions
       // because we'll need to compare elements in case of hash collisions.
       let (bucket, found) = find(element, hashValue: hashValue)
       guard !found else {
+        #if !$Embedded
         ELEMENT_TYPE_OF_SET_VIOLATES_HASHABLE_REQUIREMENTS(Element.self)
+        #else
+        fatalError("duplicate elements in a Set")
+        #endif
       }
       hashTable.insert(bucket)
       uncheckedInitialize(at: bucket, to: element)
@@ -418,7 +423,11 @@ extension _NativeSet { // Insertions
     if rehashed {
       let (b, f) = find(element)
       if f {
+        #if !$Embedded
         ELEMENT_TYPE_OF_SET_VIOLATES_HASHABLE_REQUIREMENTS(Element.self)
+        #else
+        fatalError("duplicate elements in a Set")
+        #endif
       }
       bucket = b
     }
@@ -437,7 +446,11 @@ extension _NativeSet { // Insertions
     if rehashed {
       let (b, f) = find(element)
       if f != found {
+        #if !$Embedded
         ELEMENT_TYPE_OF_SET_VIOLATES_HASHABLE_REQUIREMENTS(Element.self)
+        #else
+        fatalError("duplicate elements in a Set")
+        #endif
       }
       bucket = b
     }

stdlib/public/core/Set.swift

@@ -448,12 +448,14 @@ extension Set: Hashable {
   }
 }
 
+@_unavailableInEmbedded
 extension Set: _HasCustomAnyHashableRepresentation {
   public __consuming func _toCustomAnyHashable() -> AnyHashable? {
     return AnyHashable(_box: _SetAnyHashableBox(self))
   }
 }
 
+@_unavailableInEmbedded
 internal struct _SetAnyHashableBox<Element: Hashable>: _AnyHashableBox {
   internal let _value: Set<Element>
   internal let _canonical: Set<AnyHashable>
@@ -1034,6 +1036,7 @@ extension Set: SetAlgebra {
   }
 }
 
+@_unavailableInEmbedded
 extension Set: CustomStringConvertible, CustomDebugStringConvertible {
   /// A string that represents the contents of the set.
   public var description: String {