[stdlib] Optimize Set.isSubset<S>(of: S)

Use a temporary bitset to speed up the Sequence variant by roughly a factor of 3.

Author: lorentey

stdlib/public/core/NativeSet.swift

@@ -77,6 +77,12 @@ extension _NativeSet { // Primitive fields
     }
   }
 
+  @_alwaysEmitIntoClient
+  @inline(__always)
+  internal var bucketCount: Int {
+    _assumeNonNegative(_storage._bucketCount)
+  }
+
   @inlinable
   internal var hashTable: _HashTable {
     @inline(__always) get {
@@ -580,3 +586,26 @@ extension _NativeSet.Iterator: IteratorProtocol {
     return base.uncheckedElement(at: index)
   }
 }
+
+extension _NativeSet {
+  @_alwaysEmitIntoClient
+  internal func isSubset<S: Sequence>(of possibleSuperset: S) -> Bool
+  where S.Element == Element {
+    _UnsafeBitset.withTemporaryBitset(capacity: self.bucketCount) { seen in
+      // Mark elements in self that we've seen in `possibleSuperset`.
+      var seenCount = 0
+      for element in possibleSuperset {
+        let (bucket, found) = find(element)
+        guard found else { continue }
+        let inserted = seen.uncheckedInsert(bucket.offset)
+        if inserted {
+          seenCount += 1
+          if seenCount == self.count {
+            return true
+          }
+        }
+      }
+      return false
+    }
+  }
+}

stdlib/public/core/Set.swift

@@ -710,9 +710,11 @@ extension Set: SetAlgebra {
   public func isSubset<S: Sequence>(of possibleSuperset: S) -> Bool
   where S.Element == Element {
     guard !isEmpty else { return true }
-    
-    let other = Set(possibleSuperset)
-    return isSubset(of: other)
+    if self.count == 1 { return possibleSuperset.contains(self.first!) }
+    if let s = possibleSuperset as? Set<Element> {
+      return isSubset(of: s)
+    }
+    return _variant.convertedToNative.isSubset(of: possibleSuperset)
   }
 
   /// Returns a Boolean value that indicates whether the set is a strict subset
@@ -1081,7 +1083,7 @@ extension Set {
   public func isSubset(of other: Set<Element>) -> Bool {
     guard self.count <= other.count else { return false }
     for member in self {
-      if !other.contains(member) {
+      guard other.contains(member) else {
         return false
       }
     }