Rewrite ExplicitNull as a propertyWrapper (#3954)

Add Swift4ExplicitNull that behaves as before.

Author: wilhuff

Firestore/Swift/Source/Codable/ExplicitNull.swift

@@ -16,15 +16,65 @@
 
 import FirebaseFirestore
 
-/// Wraps around a `Optional` such that it explicitly sets the corresponding document field
-/// to Null, instead of not setting the field at all.
+#if swift(>=5.1)
+
+/// Wraps an `Optional` field in a `Codable` object such that when the field has
+/// a `nil` value it will encode to a null value in Firestore. Normally,
+/// optional fields are omitted from the encoded document.
+///
+/// This is useful for ensuring a field is present in a Firestore document, even
+/// when there is no associated value.
+@propertyWrapper
+public struct ExplicitNull<Value> {
+  var value: Value?
+
+  public init(wrappedValue value: Value?) {
+    self.value = value
+  }
+
+  public var wrappedValue: Value? {
+    get { value }
+    set { value = newValue }
+  }
+}
+
+extension ExplicitNull: Equatable where Value: Equatable {}
+
+extension ExplicitNull: Encodable where Value: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    if let value = value {
+      try container.encode(value)
+    } else {
+      try container.encodeNil()
+    }
+  }
+}
+
+extension ExplicitNull: Decodable where Value: Decodable {
+  public init(from decoder: Decoder) throws {
+    let container = try decoder.singleValueContainer()
+    if container.decodeNil() {
+      value = nil
+    } else {
+      value = try container.decode(Value.self)
+    }
+  }
+}
+
+#endif  // swift(>=5.1)
+
+/// A compatibility version of `ExplicitNull` that does not use property
+/// wrappers, suitable for use in older versions of Swift.
 ///
-/// When encoded into a Firestore document by `Firestore.Encoder`, an `Optional` field with
-/// `nil` value will be skipped, so the resulting document simply will not have the field.
+/// Wraps an `Optional` field in a `Codable` object such that when the field has
+/// a `nil` value it will encode to a null value in Firestore. Normally,
+/// optional fields are omitted from the encoded document.
 ///
-/// When setting the field to `Null` instead of skipping it is desired, `ExplicitNull` can be
-/// used instead of `Optional`.
-public enum ExplicitNull<Wrapped> {
+/// This is useful for ensuring a field is present in a Firestore document, even
+/// when there is no associated value.
+@available(swift, deprecated: 5.1)
+public enum Swift4ExplicitNull<Wrapped> {
   case none
   case some(Wrapped)
 
@@ -49,9 +99,11 @@ public enum ExplicitNull<Wrapped> {
   }
 }
 
-extension ExplicitNull: Equatable where Wrapped: Equatable {}
+@available(swift, deprecated: 5.1)
+extension Swift4ExplicitNull: Equatable where Wrapped: Equatable {}
 
-extension ExplicitNull: Encodable where Wrapped: Encodable {
+@available(swift, deprecated: 5.1)
+extension Swift4ExplicitNull: Encodable where Wrapped: Encodable {
   public func encode(to encoder: Encoder) throws {
     var container = encoder.singleValueContainer()
     switch self {
@@ -63,7 +115,8 @@ extension ExplicitNull: Encodable where Wrapped: Encodable {
   }
 }
 
-extension ExplicitNull: Decodable where Wrapped: Decodable {
+@available(swift, deprecated: 5.1)
+extension Swift4ExplicitNull: Decodable where Wrapped: Decodable {
   public init(from decoder: Decoder) throws {
     let container = try decoder.singleValueContainer()
     if container.decodeNil() {

Firestore/Swift/Tests/Codable/FirestoreEncoderTests.swift

@@ -478,9 +478,24 @@ class FirestoreEncoderTests: XCTestCase {
       .decodes(to: Model(timestamp: .pending))
   }
 
+#if swift(>=5.1)
   func testExplicitNull() throws {
     struct Model: Codable, Equatable {
-      var name: ExplicitNull<String>
+      @ExplicitNull var name: String?
+    }
+
+    assertThat(Model(name: nil))
+      .roundTrips(to: ["name": NSNull()])
+
+    assertThat(Model(name: "good name"))
+      .roundTrips(to: ["name": "good name"])
+  }
+#endif  // swift(>=5.1)
+
+  @available(swift, deprecated: 5.1)
+  func testSwift4ExplicitNull() throws {
+    struct Model: Codable, Equatable {
+      var name: Swift4ExplicitNull<String>
     }
 
     assertThat(Model(name: .none))

Firestore/Swift/Tests/Integration/CodableIntegrationTests.swift

@@ -144,10 +144,38 @@ class CodableIntegrationTests: FSTIntegrationTestCase {
     }
   }
 
+#if swift(>=5.1)
   func testExplicitNull() throws {
     struct Model: Encodable {
       var name: String
-      var explicitNull: ExplicitNull<String>
+      @ExplicitNull var explicitNull: String?
+      var optional: String?
+    }
+    let model = Model(
+      name: "name",
+      explicitNull: nil,
+      optional: nil
+    )
+
+    let docToWrite = documentRef()
+
+    for flavor in allFlavors {
+      try setData(from: model, forDocument: docToWrite, withFlavor: flavor)
+
+      let data = readDocument(forRef: docToWrite).data()
+
+      XCTAssertTrue(data!.keys.contains("explicitNull"), "Failed with flavor \(flavor)")
+      XCTAssertEqual(data!["explicitNull"] as! NSNull, NSNull(), "Failed with flavor \(flavor)")
+      XCTAssertFalse(data!.keys.contains("optional"), "Failed with flavor \(flavor)")
+    }
+  }
+#endif  // swift(>=5.1)
+
+  @available(swift, deprecated: 5.1)
+  func testSwift4ExplicitNull() throws {
+    struct Model: Encodable {
+      var name: String
+      var explicitNull: Swift4ExplicitNull<String>
       var optional: String?
     }
     let model = Model(