give up and use manual wrapper

Author: morganchen12

Firestore/Source/Public/FirebaseFirestore/FIRFirestore.h

@@ -144,7 +144,7 @@ NS_SWIFT_NAME(Firestore)
  */
 - (void)runTransactionWithBlock:(id _Nullable (^)(FIRTransaction *, NSError **))updateBlock
                      completion:(void (^)(id _Nullable result, NSError *_Nullable error))completion
-    __attribute__((swift_async_error(nonnull_error)));
+__attribute__((swift_async(none))); // Disable async import due to #9426.
 
 /**
  * Creates a write batch, used for performing multiple writes as a single

Firestore/Swift/Source/AsyncAwait/Firestore+AsyncAwait.swift

@@ -53,5 +53,50 @@ import Foundation
         }
       }
     }
+
+    /// Executes the given updateBlock and then attempts to commit the changes applied within an atomic
+    /// transaction.
+    ///
+    /// The maximum number of writes allowed in a single transaction is 500, but note that each usage of
+    /// `FieldValue.serverTimestamp()`, `FieldValue.arrayUnion()`, `FieldValue.arrayRemove()`, or
+    /// `FieldValue.increment()` inside a transaction counts as an additional write.
+    ///
+    /// In the updateBlock, a set of reads and writes can be performed atomically using the
+    /// `FIRTransaction` object passed to the block. After the updateBlock is run, Firestore will attempt
+    /// to apply the changes to the server. If any of the data read has been modified outside of this
+    /// transaction since being read, then the transaction will be retried by executing the updateBlock
+    /// again. If the transaction still fails after 5 retries, then the transaction will fail.
+    ///
+    /// Since the updateBlock may be executed multiple times, it should avoiding doing anything that
+    /// would cause side effects.
+    ///
+    /// Any value maybe be returned from the updateBlock. If the transaction is successfully committed,
+    /// then the completion block will be passed that value. The updateBlock also has an `NSError` out
+    /// parameter. If this is set, then the transaction will not attempt to commit, and the given error
+    /// will be passed to the completion block.
+    ///
+    /// The `FIRTransaction` object passed to the updateBlock contains methods for accessing documents
+    /// and collections. Unlike other firestore access, data accessed with the transaction will not
+    /// reflect local changes that have not been committed. For this reason, it is required that all
+    /// reads are performed before any writes. Transactions must be performed while online. Otherwise,
+    /// reads will fail, the final commit will fail, and the completion block will return an error.
+    ///
+    /// @param updateBlock The block to execute within the transaction context.
+    /// @param completion The block to call with the result or error of the transaction. This
+    ///     block will run even if the client is offline, unless the process is killed.
+    func runTransaction(
+      _ updateBlock: @escaping (Transaction, NSErrorPointer) -> Any?) async throws -> Any? {
+      // This needs to be wrapped in order to express a nullable return value upon success.
+      // See https://github.com/firebase/firebase-ios-sdk/issues/9426 for more details.
+      return try await withCheckedThrowingContinuation { continuation in
+        self.runTransaction(updateBlock) { anyValue, error in
+          if let err = error {
+            continuation.resume(throwing: err)
+          } else {
+            continuation.resume(returning: anyValue)
+          }
+        }
+      }
+    }
   }
 #endif

Firestore/Swift/Tests/Integration/AsyncAwaitIntegrationTests.swift

@@ -65,5 +65,16 @@ let emptyBundle = """
         .loadBundle(InputStream(data: bundle.data(using: String.Encoding.utf8)!))
       XCTAssertEqual(LoadBundleTaskState.success, bundleProgress.state)
     }
+
+    func testRunTransactionDoesNotCrashOnNilSuccess() async throws {
+      let document = collectionRef().document()
+      try await document.setData(["": ""]) // ensure document exists
+      let value = try await db.runTransaction { transact, error in
+        transact.setData(["test": "test"], forDocument: document)
+        return nil // should not crash
+      }
+
+      XCTAssertNil(value, "value should be nil on success")
+    }
   }
 #endif