fix: Fix optional doubles not building in Release mode on Swift

example/src/getTests.ts

@@ -523,6 +523,16 @@ export function getTests(
         .didNotThrow()
         .didReturn('undefined')
     ),
+    createTest('getPersonAgeOrUndefined(...) works for number', () =>
+      it(() => testObject.getPersonAgeOrUndefined({ age: 57 }))
+        .didNotThrow()
+        .equals(57)
+    ),
+    createTest('getPersonAgeOrUndefined(...) works for undefined', () =>
+      it(() => testObject.getPersonAgeOrUndefined({}))
+        .didNotThrow()
+        .equals(undefined)
+    ),
 
     createTest('complexEnumCallback(...)', async () =>
       (

packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts

@@ -468,8 +468,10 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> {
             // TODO: Remove this check for booleans once https://github.com/swiftlang/swift/issues/84848 is fixed.
             const swiftBug84848Workaround =
               optional.wrappingType.kind === 'boolean'
+
+            // TODO: Use `.value` instead of the `.has_value()`/`.pointee` once Swift has better support for `std::optional` bridging
             if (!wrapping.needsSpecialHandling && !swiftBug84848Workaround) {
-              return `${cppParameterName}.value`
+              return `${cppParameterName}.hasValue ? ${cppParameterName}.pointee : nil`
             }
             return `
 { () -> ${optional.getCode('swift')} in

packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt

@@ -422,6 +422,10 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {
     return value
   }
 
+  override fun getPersonAgeOrUndefined(partialPerson: PartialPerson): Double? {
+    return partialPerson.age
+  }
+
   override fun createArrayBufferFromNativeBuffer(copy: Boolean): ArrayBuffer {
     val hardwareBuffer =
       HardwareBuffer.create(

packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp

@@ -571,6 +571,10 @@ OptionalCallback HybridTestObjectCpp::bounceOptionalCallback(const OptionalCallb
   return value;
 }
 
+std::optional<double> HybridTestObjectCpp::getPersonAgeOrUndefined(const PartialPerson& partialPerson) {
+  return partialPerson.age;
+}
+
 std::shared_ptr<ArrayBuffer> HybridTestObjectCpp::createArrayBufferFromNativeBuffer(bool /* copy */) {
   // Let's just use the move method here for native buffer to test this too.
   std::vector<uint8_t> data;

packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp

@@ -178,6 +178,7 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   WrappedJsStruct bounceWrappedJsStyleStruct(const WrappedJsStruct& value) override;
   OptionalWrapper bounceOptionalWrapper(const OptionalWrapper& wrapper) override;
   OptionalCallback bounceOptionalCallback(const OptionalCallback& value) override;
+  std::optional<double> getPersonAgeOrUndefined(const PartialPerson& partialPerson) override;
   std::shared_ptr<ArrayBuffer> createArrayBufferFromNativeBuffer(bool /* copy */) override;
   std::shared_ptr<ArrayBuffer> createArrayBuffer() override;
   std::shared_ptr<ArrayBuffer> copyBuffer(const std::shared_ptr<ArrayBuffer>& buffer) override;

packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift

@@ -464,6 +464,10 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {
     return value
   }
 
+  func getPersonAgeOrUndefined(partialPerson: PartialPerson) throws -> Double? {
+    return partialPerson.age
+  }
+
   func createArrayBufferFromNativeBuffer(copy: Bool) throws -> ArrayBuffer {
     let data = Data(count: 1024 * 1024 * 10)  // 10 MB
     if copy {

packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp

@@ -1084,6 +1084,11 @@ namespace margelo::nitro::test {
     auto __result = method(_javaPart, JOptionalCallback::fromCpp(value));
     return __result->toCpp();
   }
+  std::optional<double> JHybridTestObjectSwiftKotlinSpec::getPersonAgeOrUndefined(const PartialPerson& partialPerson) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>(jni::alias_ref<JPartialPerson> /* partialPerson */)>("getPersonAgeOrUndefined");
+    auto __result = method(_javaPart, JPartialPerson::fromCpp(partialPerson));
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
   std::shared_ptr<ArrayBuffer> JHybridTestObjectSwiftKotlinSpec::createArrayBuffer() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JArrayBuffer::javaobject>()>("createArrayBuffer");
     auto __result = method(_javaPart);

packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp

@@ -148,6 +148,7 @@ namespace margelo::nitro::test {
     WrappedJsStruct bounceWrappedJsStyleStruct(const WrappedJsStruct& value) override;
     OptionalWrapper bounceOptionalWrapper(const OptionalWrapper& wrapper) override;
     OptionalCallback bounceOptionalCallback(const OptionalCallback& value) override;
+    std::optional<double> getPersonAgeOrUndefined(const PartialPerson& partialPerson) override;
     std::shared_ptr<ArrayBuffer> createArrayBuffer() override;
     std::shared_ptr<ArrayBuffer> createArrayBufferFromNativeBuffer(bool copy) override;
     std::shared_ptr<ArrayBuffer> copyBuffer(const std::shared_ptr<ArrayBuffer>& buffer) override;

packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt

@@ -478,6 +478,10 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() {
   @Keep
   abstract fun bounceOptionalCallback(value: OptionalCallback): OptionalCallback
 
+  @DoNotStrip
+  @Keep
+  abstract fun getPersonAgeOrUndefined(partialPerson: PartialPerson): Double?
+
   @DoNotStrip
   @Keep
   abstract fun createArrayBuffer(): ArrayBuffer

packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp

@@ -1781,6 +1781,15 @@ namespace margelo::nitro::test::bridge::swift {
     return Result<OptionalCallback>::withError(error);
   }
 
+  // pragma MARK: Result<std::optional<double>>
+  using Result_std__optional_double__ = Result<std::optional<double>>;
+  inline Result_std__optional_double__ create_Result_std__optional_double__(std::optional<double> value) noexcept {
+    return Result<std::optional<double>>::withValue(std::move(value));
+  }
+  inline Result_std__optional_double__ create_Result_std__optional_double__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<double>>::withError(error);
+  }
+
   // pragma MARK: Result<std::shared_ptr<ArrayBuffer>>
   using Result_std__shared_ptr_ArrayBuffer__ = Result<std::shared_ptr<ArrayBuffer>>;
   inline Result_std__shared_ptr_ArrayBuffer__ create_Result_std__shared_ptr_ArrayBuffer__(const std::shared_ptr<ArrayBuffer>& value) noexcept {

packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp

@@ -734,6 +734,14 @@ namespace margelo::nitro::test {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::optional<double> getPersonAgeOrUndefined(const PartialPerson& partialPerson) override {
+      auto __result = _swiftPart.getPersonAgeOrUndefined(std::forward<decltype(partialPerson)>(partialPerson));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<ArrayBuffer> createArrayBuffer() override {
       auto __result = _swiftPart.createArrayBuffer();
       if (__result.hasError()) [[unlikely]] {

packages/react-native-nitro-test/nitrogen/generated/ios/swift/Car.swift

@@ -124,7 +124,7 @@ public extension Car {
   var driver: Person? {
     @inline(__always)
     get {
-      return self.__driver.value
+      return self.__driver.hasValue ? self.__driver.pointee : nil
     }
     @inline(__always)
     set {

packages/react-native-nitro-test/nitrogen/generated/ios/swift/Func_void_std__optional_double_.swift

@@ -23,7 +23,7 @@ public final class Func_void_std__optional_double_ {
 
   @inline(__always)
   public func call(value: bridge.std__optional_double_) -> Void {
-    self.closure(value.value)
+    self.closure(value.hasValue ? value.pointee : nil)
   }
 
   /**

packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift

@@ -95,6 +95,7 @@ public protocol HybridTestObjectSwiftKotlinSpec_protocol: HybridObject {
   func bounceWrappedJsStyleStruct(value: WrappedJsStruct) throws -> WrappedJsStruct
   func bounceOptionalWrapper(wrapper: OptionalWrapper) throws -> OptionalWrapper
   func bounceOptionalCallback(value: OptionalCallback) throws -> OptionalCallback
+  func getPersonAgeOrUndefined(partialPerson: PartialPerson) throws -> Double?
   func createArrayBuffer() throws -> ArrayBuffer
   func createArrayBufferFromNativeBuffer(copy: Bool) throws -> ArrayBuffer
   func copyBuffer(buffer: ArrayBuffer) throws -> ArrayBuffer

packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift

@@ -332,7 +332,7 @@ open class HybridTestObjectSwiftKotlinSpec_cxx {
     }
     @inline(__always)
     set {
-      self.__implementation.optionalEnum = newValue.value
+      self.__implementation.optionalEnum = newValue.hasValue ? newValue.pointee : nil
     }
   }
 
@@ -989,7 +989,7 @@ open class HybridTestObjectSwiftKotlinSpec_cxx {
   @inline(__always)
   public final func tryOptionalEnum(value: bridge.std__optional_Powertrain_) -> bridge.Result_std__optional_Powertrain__ {
     do {
-      let __result = try self.__implementation.tryOptionalEnum(value: value.value)
+      let __result = try self.__implementation.tryOptionalEnum(value: value.hasValue ? value.pointee : nil)
       let __resultCpp = { () -> bridge.std__optional_Powertrain_ in
         if let __unwrappedValue = __result {
           return bridge.create_std__optional_Powertrain_(__unwrappedValue)
@@ -1358,7 +1358,7 @@ open class HybridTestObjectSwiftKotlinSpec_cxx {
   @inline(__always)
   public final func callWithOptional(value: bridge.std__optional_double_, callback: bridge.Func_void_std__optional_double_) -> bridge.Result_void_ {
     do {
-      try self.__implementation.callWithOptional(value: value.value, callback: { () -> (Double?) -> Void in
+      try self.__implementation.callWithOptional(value: value.hasValue ? value.pointee : nil, callback: { () -> (Double?) -> Void in
         let __wrappedFunction = bridge.wrap_Func_void_std__optional_double_(callback)
         return { (__maybe: Double?) -> Void in
           __wrappedFunction.call({ () -> bridge.std__optional_double_ in
@@ -1794,6 +1794,24 @@ open class HybridTestObjectSwiftKotlinSpec_cxx {
     }
   }
 
+  @inline(__always)
+  public final func getPersonAgeOrUndefined(partialPerson: PartialPerson) -> bridge.Result_std__optional_double__ {
+    do {
+      let __result = try self.__implementation.getPersonAgeOrUndefined(partialPerson: partialPerson)
+      let __resultCpp = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_double__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_double__(__exceptionPtr)
+    }
+  }
+
   @inline(__always)
   public final func createArrayBuffer() -> bridge.Result_std__shared_ptr_ArrayBuffer__ {
     do {

packages/react-native-nitro-test/nitrogen/generated/ios/swift/PartialPerson.swift

@@ -62,7 +62,7 @@ public extension PartialPerson {
   var age: Double? {
     @inline(__always)
     get {
-      return self.__age.value
+      return self.__age.hasValue ? self.__age.pointee : nil
     }
     @inline(__always)
     set {

packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp

@@ -116,6 +116,7 @@ namespace margelo::nitro::test {
       prototype.registerHybridMethod("bounceWrappedJsStyleStruct", &HybridTestObjectCppSpec::bounceWrappedJsStyleStruct);
       prototype.registerHybridMethod("bounceOptionalWrapper", &HybridTestObjectCppSpec::bounceOptionalWrapper);
       prototype.registerHybridMethod("bounceOptionalCallback", &HybridTestObjectCppSpec::bounceOptionalCallback);
+      prototype.registerHybridMethod("getPersonAgeOrUndefined", &HybridTestObjectCppSpec::getPersonAgeOrUndefined);
       prototype.registerHybridMethod("createArrayBuffer", &HybridTestObjectCppSpec::createArrayBuffer);
       prototype.registerHybridMethod("createArrayBufferFromNativeBuffer", &HybridTestObjectCppSpec::createArrayBufferFromNativeBuffer);
       prototype.registerHybridMethod("copyBuffer", &HybridTestObjectCppSpec::copyBuffer);

packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp

@@ -216,6 +216,7 @@ namespace margelo::nitro::test {
       virtual WrappedJsStruct bounceWrappedJsStyleStruct(const WrappedJsStruct& value) = 0;
       virtual OptionalWrapper bounceOptionalWrapper(const OptionalWrapper& wrapper) = 0;
       virtual OptionalCallback bounceOptionalCallback(const OptionalCallback& value) = 0;
+      virtual std::optional<double> getPersonAgeOrUndefined(const PartialPerson& partialPerson) = 0;
       virtual std::shared_ptr<ArrayBuffer> createArrayBuffer() = 0;
       virtual std::shared_ptr<ArrayBuffer> createArrayBufferFromNativeBuffer(bool copy) = 0;
       virtual std::shared_ptr<ArrayBuffer> copyBuffer(const std::shared_ptr<ArrayBuffer>& buffer) = 0;

packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp

@@ -109,6 +109,7 @@ namespace margelo::nitro::test {
       prototype.registerHybridMethod("bounceWrappedJsStyleStruct", &HybridTestObjectSwiftKotlinSpec::bounceWrappedJsStyleStruct);
       prototype.registerHybridMethod("bounceOptionalWrapper", &HybridTestObjectSwiftKotlinSpec::bounceOptionalWrapper);
       prototype.registerHybridMethod("bounceOptionalCallback", &HybridTestObjectSwiftKotlinSpec::bounceOptionalCallback);
+      prototype.registerHybridMethod("getPersonAgeOrUndefined", &HybridTestObjectSwiftKotlinSpec::getPersonAgeOrUndefined);
       prototype.registerHybridMethod("createArrayBuffer", &HybridTestObjectSwiftKotlinSpec::createArrayBuffer);
       prototype.registerHybridMethod("createArrayBufferFromNativeBuffer", &HybridTestObjectSwiftKotlinSpec::createArrayBufferFromNativeBuffer);
       prototype.registerHybridMethod("copyBuffer", &HybridTestObjectSwiftKotlinSpec::copyBuffer);

packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp

@@ -204,6 +204,7 @@ namespace margelo::nitro::test {
       virtual WrappedJsStruct bounceWrappedJsStyleStruct(const WrappedJsStruct& value) = 0;
       virtual OptionalWrapper bounceOptionalWrapper(const OptionalWrapper& wrapper) = 0;
       virtual OptionalCallback bounceOptionalCallback(const OptionalCallback& value) = 0;
+      virtual std::optional<double> getPersonAgeOrUndefined(const PartialPerson& partialPerson) = 0;
       virtual std::shared_ptr<ArrayBuffer> createArrayBuffer() = 0;
       virtual std::shared_ptr<ArrayBuffer> createArrayBufferFromNativeBuffer(bool copy) = 0;
       virtual std::shared_ptr<ArrayBuffer> copyBuffer(const std::shared_ptr<ArrayBuffer>& buffer) = 0;

packages/react-native-nitro-test/src/specs/TestObject.nitro.ts

@@ -234,6 +234,8 @@ interface SharedTestObjectProps {
   bounceWrappedJsStyleStruct(value: WrappedJsStruct): WrappedJsStruct
   bounceOptionalWrapper(wrapper: OptionalWrapper): OptionalWrapper
   bounceOptionalCallback(value: OptionalCallback): OptionalCallback
+  // tests a specific std::optional<double> bug in Swift
+  getPersonAgeOrUndefined(partialPerson: PartialPerson): number | undefined
 
   // ArrayBuffers
   createArrayBuffer(): ArrayBuffer