bitwarden/sdk-internal@c975847 1.0.0-2487-c975847 - [PM-23785] Use actual error types in UniFFI (bitwarden/sdk-internal#424)

Author: bitwarden-devops-bot

Package.swift

@@ -30,7 +30,7 @@ let package = Package(
             dependencies: ["BitwardenSdk"]),
         .binaryTarget(
   name: "BitwardenFFI",
-  url: "https://github.com/bitwarden/sdk-swift/releases/download/v1.0.0-2483-d0262d3/BitwardenFFI-1.0.0-d0262d3.xcframework.zip",
-  checksum: "795070076d259c537451f25f997d019d040bbdd8656f57153fe4b0106543b8f4")
+  url: "https://github.com/bitwarden/sdk-swift/releases/download/v1.0.0-2487-c975847/BitwardenFFI-1.0.0-c975847.xcframework.zip",
+  checksum: "f6b37a81b6b040b045c364197a616af2bf691a6d9053cac11a88d93603514827")
     ]
 )

Sources/BitwardenSdk/BitwardenCollections.swift

@@ -352,21 +352,31 @@ private func uniffiTraitInterfaceCallWithError<T, E>(
         callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error))
     }
 }
+// Initial value and increment amount for handles. 
+// These ensure that SWIFT handles always have the lowest bit set
+fileprivate let UNIFFI_HANDLEMAP_INITIAL: UInt64 = 1
+fileprivate let UNIFFI_HANDLEMAP_DELTA: UInt64 = 2
+
 fileprivate final class UniffiHandleMap<T>: @unchecked Sendable {
     // All mutation happens with this lock held, which is why we implement @unchecked Sendable.
     private let lock = NSLock()
     private var map: [UInt64: T] = [:]
-    private var currentHandle: UInt64 = 1
+    private var currentHandle: UInt64 = UNIFFI_HANDLEMAP_INITIAL
 
     func insert(obj: T) -> UInt64 {
         lock.withLock {
-            let handle = currentHandle
-            currentHandle += 1
-            map[handle] = obj
-            return handle
+            return doInsert(obj)
         }
     }
 
+    // Low-level insert function, this assumes `lock` is held.
+    private func doInsert(_ obj: T) -> UInt64 {
+        let handle = currentHandle
+        currentHandle += UNIFFI_HANDLEMAP_DELTA
+        map[handle] = obj
+        return handle
+    }
+
      func get(handle: UInt64) throws -> T {
         try lock.withLock {
             guard let obj = map[handle] else {
@@ -376,6 +386,15 @@ fileprivate final class UniffiHandleMap<T>: @unchecked Sendable {
         }
     }
 
+     func clone(handle: UInt64) throws -> UInt64 {
+        try lock.withLock {
+            guard let obj = map[handle] else {
+                throw UniffiInternalError.unexpectedStaleHandle
+            }
+            return doInsert(obj)
+        }
+    }
+
     @discardableResult
     func remove(handle: UInt64) throws -> T {
         try lock.withLock {
@@ -494,6 +513,9 @@ extension Collection: Sendable {}
 #endif
 
 
+
+
+
 extension Collection: Equatable, Hashable {
     public static func ==(lhs: Collection, rhs: Collection) -> Bool {
         if lhs.id != rhs.id {
@@ -618,6 +640,9 @@ extension CollectionView: Sendable {}
 #endif
 
 
+
+
+
 extension CollectionView: Equatable, Hashable {
     public static func ==(lhs: CollectionView, rhs: CollectionView) -> Bool {
         if lhs.id != rhs.id {
@@ -706,6 +731,82 @@ public func FfiConverterTypeCollectionView_lower(_ value: CollectionView) -> Rus
     return FfiConverterTypeCollectionView.lower(value)
 }
 
+
+public enum CollectionDecryptError: Swift.Error {
+
+    
+    
+    case Crypto(message: String)
+    
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeCollectionDecryptError: FfiConverterRustBuffer {
+    typealias SwiftType = CollectionDecryptError
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CollectionDecryptError {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+
+        
+
+        
+        case 1: return .Crypto(
+            message: try FfiConverterString.read(from: &buf)
+        )
+        
+
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: CollectionDecryptError, into buf: inout [UInt8]) {
+        switch value {
+
+        
+
+        
+        case .Crypto(_ /* message is ignored*/):
+            writeInt(&buf, Int32(1))
+
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCollectionDecryptError_lift(_ buf: RustBuffer) throws -> CollectionDecryptError {
+    return try FfiConverterTypeCollectionDecryptError.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCollectionDecryptError_lower(_ value: CollectionDecryptError) -> RustBuffer {
+    return FfiConverterTypeCollectionDecryptError.lower(value)
+}
+
+
+extension CollectionDecryptError: Equatable, Hashable {}
+
+
+
+
+extension CollectionDecryptError: Foundation.LocalizedError {
+    public var errorDescription: String? {
+        String(reflecting: self)
+    }
+}
+
+
+
+
 // Note that we don't yet support `indirect` for enums.
 // See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
 /**
@@ -723,9 +824,8 @@ public enum CollectionType : UInt8 {
      * OrganizationDataOwnership (formerly PersonalOwnership) policy enabled.
      */
     case defaultUserCollection = 1
-}
-
 
+}
 #if compiler(>=6)
 extension CollectionType: Sendable {}
 #endif
@@ -779,10 +879,17 @@ public func FfiConverterTypeCollectionType_lower(_ value: CollectionType) -> Rus
 }
 
 
+
+
 extension CollectionType: Equatable, Hashable {}
 
 
 
+
+
+
+
+
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
@@ -884,15 +991,15 @@ private enum InitializationResult {
 // the code inside is only computed once.
 private let initializationResult: InitializationResult = {
     // Get the bindings contract version from our ComponentInterface
-    let bindings_contract_version = 29
+    let bindings_contract_version = 30
     // Get the scaffolding contract version by calling the into the dylib
     let scaffolding_contract_version = ffi_bitwarden_collections_uniffi_contract_version()
     if bindings_contract_version != scaffolding_contract_version {
         return InitializationResult.contractVersionMismatch
     }
 
-    uniffiEnsureBitwardenCoreInitialized()
     uniffiEnsureBitwardenCryptoInitialized()
+    uniffiEnsureBitwardenCoreInitialized()
     return InitializationResult.ok
 }()