diff --git a/packages/nitrogen/src/syntax/swift/SwiftMethodHelpers.ts b/packages/nitrogen/src/syntax/swift/SwiftMethodHelpers.ts index b9c533c173..3851001d18 100644 --- a/packages/nitrogen/src/syntax/swift/SwiftMethodHelpers.ts +++ b/packages/nitrogen/src/syntax/swift/SwiftMethodHelpers.ts @@ -10,6 +10,7 @@ import { SwiftBorrowedPointerType } from './types/SwiftBorrowedPointerType.js' import { SwiftCxxBorrowedPointerType } from './types/SwiftCxxBorrowedPointerType.js' import { SwiftCxxOutPointerType } from './types/SwiftCxxOutPointerType.js' import { SwiftOutPointerType } from './types/SwiftOutPointerType.js' +import { SwiftResultConsumerType } from './types/SwiftResultConsumerType.js' import { SwiftResultType } from './types/SwiftResultType.js' import { SwiftRetainedPointerType } from './types/SwiftRetainedPointerType.js' import { SwiftVoidType } from './types/SwiftVoidType.js' @@ -22,6 +23,8 @@ export interface SwiftArgument { /** Swift functions exported to C++ take result storage as their last parameter. */ export const SWIFT_RESULT_STORAGE = '__outResult' +/** Throwing Swift functions returning Swift values take a result consumer instead. */ +const SWIFT_RESULT_CONSUMER = '__onResult' /** A value passed between C++ and a Swift function exported to C++. */ export interface SwiftBridgeParameter { @@ -88,8 +91,8 @@ export function prepareSwiftMethod(nativeMethod: Method, isThrowing: boolean, co exportedReturnType = new SwiftRetainedPointerType(returnType) } else if (isThrowing && !returnType.canImportFromCpp) { // Swift cannot import Result while a Swift-native T is incomplete. - // Return Result alongside its value buffer; Core constructs Result. - exportedReturnType = new SwiftOutPointerType(returnType) + // Return Result and lend the successful value to C++ during the call. + exportedReturnType = new SwiftResultConsumerType(returnType) } else { exportedReturnType = returnType } @@ -104,16 +107,19 @@ export function prepareSwiftMethod(nativeMethod: Method, isThrowing: boolean, co } } -/** The Result returned by a Swift function; storage holds its value instead. */ +/** The Result returned by a Swift function; indirect results use a separate parameter. */ export function getSwiftResultType(returnType: SwiftType, config: NitroConfig = NitroConfig.current): SwiftResultType { - if (returnType instanceof SwiftOutPointerType) { + if (returnType instanceof SwiftOutPointerType || returnType instanceof SwiftResultConsumerType) { return new SwiftResultType(new SwiftVoidType(), config) } return new SwiftResultType(returnType, config) } -/** The parameters of a Swift function exported to C++, including result storage. */ +/** The parameters of a Swift function exported to C++, including indirect results. */ export function getSwiftBridgeParameters(parameters: SwiftBridgeParameter[], returnType: SwiftType): SwiftBridgeParameter[] { + if (returnType instanceof SwiftResultConsumerType) { + return [...parameters, { name: SWIFT_RESULT_CONSUMER, type: returnType }] + } if (returnType instanceof SwiftOutPointerType) { return [...parameters, { name: SWIFT_RESULT_STORAGE, type: returnType }] } @@ -130,13 +136,17 @@ interface CppToSwiftCallOptions { /** * C++ code that calls a Swift function and returns its value or throws its error. - * Pointer types pass the arguments and result storage around the call. + * Adapters borrow arguments and receive indirect results during the call. */ export function createCppToSwiftCall({ parameters, returnType, returnsVoid, getCppInvocation }: CppToSwiftCallOptions): string { // Borrowed pointers shadow the values they point to. const cppArguments = parameters.map((parameter) => parameter.name) let cppSwiftInvocation: string - if (returnType instanceof SwiftOutPointerType) { + if (returnType instanceof SwiftResultConsumerType) { + const cppConsumerArguments = [...cppArguments, SWIFT_RESULT_CONSUMER] + const cppInvocation = getCppInvocation(cppConsumerArguments) + cppSwiftInvocation = returnType.receive({ consumer: SWIFT_RESULT_CONSUMER, invocation: cppInvocation }) + } else if (returnType instanceof SwiftOutPointerType) { const cppStorageArguments = [...cppArguments, SWIFT_RESULT_STORAGE] cppSwiftInvocation = returnType.tryAllocate(SWIFT_RESULT_STORAGE, getCppInvocation(cppStorageArguments)) } else { @@ -210,7 +220,7 @@ interface SwiftResultBodyOptions { /** * Swift statements that return the value of `invocation` to C++ as a Result, - * initializing the storage pointer when the value is returned through storage. + * supplying indirect results through a borrowed value or initialized storage. */ export function createSwiftResultBody({ invocation, returnType, resultType, returnsVoid }: SwiftResultBodyOptions): string { if (returnsVoid) { @@ -220,6 +230,14 @@ return ${resultType}.withValue() `.trim() } const swiftValue = returnType.fromSwift('value') + if (returnType instanceof SwiftResultConsumerType) { + const consumeCode = returnType.consume({ consumer: SWIFT_RESULT_CONSUMER, value: swiftValue }) + return ` +let value = ${invocation} +${consumeCode} +return ${resultType}.withValue() +`.trim() + } if (returnType instanceof SwiftOutPointerType) { const initializeCode = returnType.initialize('swift', SWIFT_RESULT_STORAGE, swiftValue) return ` @@ -318,5 +336,6 @@ export function getSwiftMethodImports(callable: SwiftMethodInfo): SourceImport<' publicSwiftTypes.push(callable.exportedReturnType) } const swiftParameterTypes = callable.parameters.map((parameter) => parameter.type) - return [...getSwiftImports(publicSwiftTypes, 'public'), ...getSwiftImports([callable.returnType, ...swiftParameterTypes], 'internal')] + const swiftImplementationTypes = [callable.returnType, callable.exportedReturnType, ...swiftParameterTypes] + return [...getSwiftImports(publicSwiftTypes, 'public'), ...getSwiftImports(swiftImplementationTypes, 'internal')] } diff --git a/packages/nitrogen/src/syntax/swift/types/SwiftResultConsumerType.ts b/packages/nitrogen/src/syntax/swift/types/SwiftResultConsumerType.ts new file mode 100644 index 0000000000..0121de03a4 --- /dev/null +++ b/packages/nitrogen/src/syntax/swift/types/SwiftResultConsumerType.ts @@ -0,0 +1,66 @@ +import type { Language } from '../../../getPlatformSpecs.js' +import { indent } from '../../../utils.js' +import type { SourceImport } from '../../SourceFile.js' +import { SwiftPointerType } from './SwiftPointerType.js' + +interface ReceiveOptions { + /** The name of the consumer pointer. */ + consumer: string + /** The Swift call that returns the status and lends its value to the consumer. */ + invocation: string +} + +interface ConsumeOptions { + /** The name of the consumer pointer. */ + consumer: string + /** The bridge value to lend. */ + value: string +} + +/** + * Points to a C++ SwiftResultConsumer. Swift lends a successful return value to it, + * so the value does not cross the boundary in a boxed swift::Optional. + * TODO: Pass margelo.nitro.SwiftResultConsumer directly once our minimum Xcode includes + * https://github.com/swiftlang/swift/pull/93321, which fixes https://github.com/swiftlang/swift/issues/93318. + */ +export class SwiftResultConsumerType extends SwiftPointerType { + protected readonly isMutable = false + + /** The value to lend; see `consume()`. */ + fromSwift(value: string): string { + return this.pointee.fromSwift(value) + } + toSwift(value: string): string { + return this.pointee.toSwift(value) + } + + /** C++ code that returns the Result of `invocation`, holding the value Swift lent to `consumer`. */ + receive({ consumer, invocation }: ReceiveOptions): string { + const type = this.pointee.getCode('c++', { context: 'type-argument' }) + const pointerType = this.getCode('c++', { context: 'value' }) + return ` +receiveSwiftResult<${type}>([&](${pointerType} ${consumer}) { + return ${indent(invocation, ' ')}; +}) +`.trim() + } + + /** Swift code that lends `value` to `consumer` for the duration of the call. */ + consume({ consumer, value }: ConsumeOptions): string { + return ` +withUnsafePointer(to: ${value}) { pointer in + margelo.nitro.SwiftResultConsumer.consume(${consumer}, UnsafeRawPointer(pointer)) +} +`.trim() + } + + /** Swift calls the consumer through its C++ declaration. */ + override getRequiredImports(language?: Language): SourceImport[] { + switch (language) { + case 'swift': + return [{ language: language, name: 'NitroModulesAppleCxx', access: 'internal' }] + default: + return [] + } + } +} diff --git a/tests/react-native/packages/react-native-nitro-test-external/nitrogen/generated/apple/c++/HybridTestViewSpecSwift.cpp b/tests/react-native/packages/react-native-nitro-test-external/nitrogen/generated/apple/c++/HybridTestViewSpecSwift.cpp index 24d0df2037..c6e815b457 100644 --- a/tests/react-native/packages/react-native-nitro-test-external/nitrogen/generated/apple/c++/HybridTestViewSpecSwift.cpp +++ b/tests/react-native/packages/react-native-nitro-test-external/nitrogen/generated/apple/c++/HybridTestViewSpecSwift.cpp @@ -48,8 +48,8 @@ namespace margelo::nitro::test::external { } swift::String HybridTestViewSpecSwift::getModuleName() { - auto __result = withSwiftResult([&](void* __outResult) { - return _swiftPart.getModuleName(__outResult); + auto __result = receiveSwiftResult([&](const void* __onResult) { + return _swiftPart.getModuleName(__onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); diff --git a/tests/react-native/packages/react-native-nitro-test-external/nitrogen/generated/apple/swift/HybridTestViewSpec_cxx.swift b/tests/react-native/packages/react-native-nitro-test-external/nitrogen/generated/apple/swift/HybridTestViewSpec_cxx.swift index 50319bd584..5c5d0827d4 100644 --- a/tests/react-native/packages/react-native-nitro-test-external/nitrogen/generated/apple/swift/HybridTestViewSpec_cxx.swift +++ b/tests/react-native/packages/react-native-nitro-test-external/nitrogen/generated/apple/swift/HybridTestViewSpec_cxx.swift @@ -7,6 +7,7 @@ internal import NitroModules internal import CxxStdlib internal import NitroTestExternalAppleCxx +internal import NitroModulesAppleCxx /** * A class implementation that bridges HybridTestViewSpec over to C++. @@ -156,10 +157,12 @@ public final class HybridTestViewSpec_cxx { } } - public final func getModuleName(__outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func getModuleName(__onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.getModuleName() - __outResult.assumingMemoryBound(to: String.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) diff --git a/tests/react-native/packages/react-native-nitro-test/nitrogen/generated/apple/c++/HybridBenchmarkObjectSwiftKotlinSpecSwift.cpp b/tests/react-native/packages/react-native-nitro-test/nitrogen/generated/apple/c++/HybridBenchmarkObjectSwiftKotlinSpecSwift.cpp index 54a9371c79..f3c61d0949 100644 --- a/tests/react-native/packages/react-native-nitro-test/nitrogen/generated/apple/c++/HybridBenchmarkObjectSwiftKotlinSpecSwift.cpp +++ b/tests/react-native/packages/react-native-nitro-test/nitrogen/generated/apple/c++/HybridBenchmarkObjectSwiftKotlinSpecSwift.cpp @@ -48,8 +48,8 @@ namespace margelo::nitro::test { } swift::String HybridBenchmarkObjectSwiftKotlinSpecSwift::addStrings(const swift::String& a, const swift::String& b) { - auto __result = withSwiftResult([&](void* __outResult) { - return _swiftPart.addStrings(a, b, __outResult); + auto __result = receiveSwiftResult([&](const void* __onResult) { + return _swiftPart.addStrings(a, b, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -58,8 +58,8 @@ namespace margelo::nitro::test { } swift::Array HybridBenchmarkObjectSwiftKotlinSpecSwift::bounceNumbers(const swift::Array& array) { - auto __result = withSwiftResult>([&](void* __outResult) { - return _swiftPart.bounceNumbers(array, __outResult); + auto __result = receiveSwiftResult>([&](const void* __onResult) { + return _swiftPart.bounceNumbers(array, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -68,8 +68,8 @@ namespace margelo::nitro::test { } ::NitroTest::Car HybridBenchmarkObjectSwiftKotlinSpecSwift::bounceCar(const ::NitroTest::Car& car) { - auto __result = withSwiftResult<::NitroTest::Car>([&](void* __outResult) { - return _swiftPart.bounceCar(car, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Car>([&](const void* __onResult) { + return _swiftPart.bounceCar(car, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -78,8 +78,8 @@ namespace margelo::nitro::test { } ::NitroTest::Record_swift__String_double HybridBenchmarkObjectSwiftKotlinSpecSwift::bounceSimpleMap(const ::NitroTest::Record_swift__String_double& map) { - auto __result = withSwiftResult<::NitroTest::Record_swift__String_double>([&](void* __outResult) { - return _swiftPart.bounceSimpleMap(map, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Record_swift__String_double>([&](const void* __onResult) { + return _swiftPart.bounceSimpleMap(map, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -88,8 +88,8 @@ namespace margelo::nitro::test { } swift::String HybridBenchmarkObjectSwiftKotlinSpecSwift::tryOptionalParams(double num, bool boo, const swift::Optional& str) { - auto __result = withSwiftResult([&](void* __outResult) { - return _swiftPart.tryOptionalParams(num, boo, str, __outResult); + auto __result = receiveSwiftResult([&](const void* __onResult) { + return _swiftPart.tryOptionalParams(num, boo, str, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -98,8 +98,8 @@ namespace margelo::nitro::test { } ::NitroTest::Variant_Double_String_cxx HybridBenchmarkObjectSwiftKotlinSpecSwift::passVariant(const ::NitroTest::Variant_Bool__Double___String__Double_String_cxx& either) { - auto __result = withSwiftResult<::NitroTest::Variant_Double_String_cxx>([&](void* __outResult) { - return _swiftPart.passVariant(either, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Variant_Double_String_cxx>([&](const void* __onResult) { + return _swiftPart.passVariant(either, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); diff --git a/tests/react-native/packages/react-native-nitro-test/nitrogen/generated/apple/swift/HybridBenchmarkObjectSwiftKotlinSpec_cxx.swift b/tests/react-native/packages/react-native-nitro-test/nitrogen/generated/apple/swift/HybridBenchmarkObjectSwiftKotlinSpec_cxx.swift index cf58ca61c1..73ebf5e560 100644 --- a/tests/react-native/packages/react-native-nitro-test/nitrogen/generated/apple/swift/HybridBenchmarkObjectSwiftKotlinSpec_cxx.swift +++ b/tests/react-native/packages/react-native-nitro-test/nitrogen/generated/apple/swift/HybridBenchmarkObjectSwiftKotlinSpec_cxx.swift @@ -7,6 +7,7 @@ public import NitroModules internal import CxxStdlib internal import NitroTestAppleCxx +internal import NitroModulesAppleCxx /** * A class implementation that bridges HybridBenchmarkObjectSwiftKotlinSpec over to C++. @@ -161,60 +162,72 @@ public final class HybridBenchmarkObjectSwiftKotlinSpec_cxx { } } - public final func addStrings(a: String, b: String, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func addStrings(a: String, b: String, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.addStrings(a: a, b: b) - __outResult.assumingMemoryBound(to: String.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceNumbers(array: [Double], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceNumbers(array: [Double], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceNumbers(array: array) - __outResult.assumingMemoryBound(to: [Double].self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceCar(car: Car, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceCar(car: Car, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceCar(car: car) - __outResult.assumingMemoryBound(to: Car.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceSimpleMap(map: Record_swift__String_double, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceSimpleMap(map: Record_swift__String_double, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceSimpleMap(map: map.dictionary) - __outResult.assumingMemoryBound(to: Record_swift__String_double.self).initialize(to: Record_swift__String_double(value)) + withUnsafePointer(to: Record_swift__String_double(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func tryOptionalParams(num: Double, boo: Bool, str: String?, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func tryOptionalParams(num: Double, boo: Bool, str: String?, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.tryOptionalParams(num: num, boo: boo, str: str) - __outResult.assumingMemoryBound(to: String.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func passVariant(either: Variant_Bool__Double___String__Double_String_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func passVariant(either: Variant_Bool__Double___String__Double_String_cxx, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.passVariant(either: either.value) - __outResult.assumingMemoryBound(to: Variant_Double_String_cxx.self).initialize(to: Variant_Double_String_cxx(value)) + withUnsafePointer(to: Variant_Double_String_cxx(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) diff --git a/tests/standalone/nitro-test-external/nitrogen/generated/apple/c++/HybridBaseSpecSwift.cpp b/tests/standalone/nitro-test-external/nitrogen/generated/apple/c++/HybridBaseSpecSwift.cpp index 94b610bc88..109f61bdfa 100644 --- a/tests/standalone/nitro-test-external/nitrogen/generated/apple/c++/HybridBaseSpecSwift.cpp +++ b/tests/standalone/nitro-test-external/nitrogen/generated/apple/c++/HybridBaseSpecSwift.cpp @@ -33,8 +33,8 @@ namespace margelo::nitro::test::external { } ::NitroTestExternal::Size HybridBaseSpecSwift::bounceSize(const ::NitroTestExternal::Size& size) { - auto __result = withSwiftResult<::NitroTestExternal::Size>([&](void* __outResult) { - return _swiftPart.bounceSize(size, __outResult); + auto __result = receiveSwiftResult<::NitroTestExternal::Size>([&](const void* __onResult) { + return _swiftPart.bounceSize(size, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -43,8 +43,8 @@ namespace margelo::nitro::test::external { } ::NitroTestExternal::SizeUnit HybridBaseSpecSwift::bounceSizeUnit(::NitroTestExternal::SizeUnit unit) { - auto __result = withSwiftResult<::NitroTestExternal::SizeUnit>([&](void* __outResult) { - return _swiftPart.bounceSizeUnit(unit, __outResult); + auto __result = receiveSwiftResult<::NitroTestExternal::SizeUnit>([&](const void* __onResult) { + return _swiftPart.bounceSizeUnit(unit, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); diff --git a/tests/standalone/nitro-test-external/nitrogen/generated/apple/c++/HybridSomeExternalObjectSpecSwift.cpp b/tests/standalone/nitro-test-external/nitrogen/generated/apple/c++/HybridSomeExternalObjectSpecSwift.cpp index 18eae12d2d..b3e15c6421 100644 --- a/tests/standalone/nitro-test-external/nitrogen/generated/apple/c++/HybridSomeExternalObjectSpecSwift.cpp +++ b/tests/standalone/nitro-test-external/nitrogen/generated/apple/c++/HybridSomeExternalObjectSpecSwift.cpp @@ -33,8 +33,8 @@ namespace margelo::nitro::test::external { // Methods swift::String HybridSomeExternalObjectSpecSwift::getValue() { - auto __result = withSwiftResult([&](void* __outResult) { - return _swiftPart.getValue(__outResult); + auto __result = receiveSwiftResult([&](const void* __onResult) { + return _swiftPart.getValue(__onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -43,8 +43,8 @@ namespace margelo::nitro::test::external { } ::NitroTestExternal::OptionalPrimitivesHolder HybridSomeExternalObjectSpecSwift::createOptionalPrimitivesHolder(const swift::Optional& optionalNumber, const swift::Optional& optionalBoolean, const swift::Optional& optionalUInt64, const swift::Optional& optionalInt64) { - auto __result = withSwiftResult<::NitroTestExternal::OptionalPrimitivesHolder>([&](void* __outResult) { - return _swiftPart.createOptionalPrimitivesHolder(optionalNumber, optionalBoolean, optionalUInt64, optionalInt64, __outResult); + auto __result = receiveSwiftResult<::NitroTestExternal::OptionalPrimitivesHolder>([&](const void* __onResult) { + return _swiftPart.createOptionalPrimitivesHolder(optionalNumber, optionalBoolean, optionalUInt64, optionalInt64, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); diff --git a/tests/standalone/nitro-test-external/nitrogen/generated/apple/swift/HybridBaseSpec_cxx.swift b/tests/standalone/nitro-test-external/nitrogen/generated/apple/swift/HybridBaseSpec_cxx.swift index 509097d05a..85847c7e0f 100644 --- a/tests/standalone/nitro-test-external/nitrogen/generated/apple/swift/HybridBaseSpec_cxx.swift +++ b/tests/standalone/nitro-test-external/nitrogen/generated/apple/swift/HybridBaseSpec_cxx.swift @@ -7,6 +7,7 @@ internal import NitroModules internal import CxxStdlib internal import NitroTestExternalAppleCxx +internal import NitroModulesAppleCxx /** * A class implementation that bridges HybridBaseSpec over to C++. @@ -143,20 +144,24 @@ public final class HybridBaseSpec_cxx { } } - public final func bounceSize(size: Size, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceSize(size: Size, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceSize(size: size) - __outResult.assumingMemoryBound(to: Size.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceSizeUnit(unit: SizeUnit, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceSizeUnit(unit: SizeUnit, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceSizeUnit(unit: unit) - __outResult.assumingMemoryBound(to: SizeUnit.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) diff --git a/tests/standalone/nitro-test-external/nitrogen/generated/apple/swift/HybridSomeExternalObjectSpec_cxx.swift b/tests/standalone/nitro-test-external/nitrogen/generated/apple/swift/HybridSomeExternalObjectSpec_cxx.swift index c756889858..a3eb0aeafa 100644 --- a/tests/standalone/nitro-test-external/nitrogen/generated/apple/swift/HybridSomeExternalObjectSpec_cxx.swift +++ b/tests/standalone/nitro-test-external/nitrogen/generated/apple/swift/HybridSomeExternalObjectSpec_cxx.swift @@ -7,6 +7,7 @@ internal import NitroModules internal import CxxStdlib internal import NitroTestExternalAppleCxx +internal import NitroModulesAppleCxx /** * A class implementation that bridges HybridSomeExternalObjectSpec over to C++. @@ -135,20 +136,24 @@ public final class HybridSomeExternalObjectSpec_cxx { // Methods - public final func getValue(__outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func getValue(__onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.getValue() - __outResult.assumingMemoryBound(to: String.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func createOptionalPrimitivesHolder(optionalNumber: Double?, optionalBoolean: Bool?, optionalUInt64: UInt64?, optionalInt64: Int64?, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func createOptionalPrimitivesHolder(optionalNumber: Double?, optionalBoolean: Bool?, optionalUInt64: UInt64?, optionalInt64: Int64?, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.createOptionalPrimitivesHolder(optionalNumber: optionalNumber, optionalBoolean: optionalBoolean, optionalUInt64: optionalUInt64, optionalInt64: optionalInt64) - __outResult.assumingMemoryBound(to: OptionalPrimitivesHolder.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridBaseSpecSwift.cpp b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridBaseSpecSwift.cpp index b2de033d07..e476446077 100644 --- a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridBaseSpecSwift.cpp +++ b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridBaseSpecSwift.cpp @@ -25,8 +25,8 @@ namespace margelo::nitro::test { // Methods ::NitroTest::Size HybridBaseSpecSwift::bounceSize(const ::NitroTest::Size& size) { - auto __result = withSwiftResult<::NitroTest::Size>([&](void* __outResult) { - return _swiftPart.bounceSize(size, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Size>([&](const void* __onResult) { + return _swiftPart.bounceSize(size, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -35,8 +35,8 @@ namespace margelo::nitro::test { } ::NitroTest::SizeUnit HybridBaseSpecSwift::bounceSizeUnit(::NitroTest::SizeUnit unit) { - auto __result = withSwiftResult<::NitroTest::SizeUnit>([&](void* __outResult) { - return _swiftPart.bounceSizeUnit(unit, __outResult); + auto __result = receiveSwiftResult<::NitroTest::SizeUnit>([&](const void* __onResult) { + return _swiftPart.bounceSizeUnit(unit, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridChildSpecSwift.cpp b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridChildSpecSwift.cpp index 0683d1c601..b2069faadc 100644 --- a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridChildSpecSwift.cpp +++ b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridChildSpecSwift.cpp @@ -25,8 +25,8 @@ namespace margelo::nitro::test { // Methods ::NitroTest::NamedVariant_cxx HybridChildSpecSwift::bounceVariant(const ::NitroTest::NamedVariant_cxx& variant) { - auto __result = withSwiftResult<::NitroTest::NamedVariant_cxx>([&](void* __outResult) { - return _swiftPart.bounceVariant(variant, __outResult); + auto __result = receiveSwiftResult<::NitroTest::NamedVariant_cxx>([&](const void* __onResult) { + return _swiftPart.bounceVariant(variant, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridPlatformObjectSpecSwift.cpp b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridPlatformObjectSpecSwift.cpp index b9698c72a7..52d49e1fda 100644 --- a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridPlatformObjectSpecSwift.cpp +++ b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridPlatformObjectSpecSwift.cpp @@ -21,8 +21,8 @@ namespace margelo::nitro::test { // Methods swift::String HybridPlatformObjectSpecSwift::getOSVersion() { - auto __result = withSwiftResult([&](void* __outResult) { - return _swiftPart.getOSVersion(__outResult); + auto __result = receiveSwiftResult([&](const void* __onResult) { + return _swiftPart.getOSVersion(__onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridTestObjectSwiftKotlinSpecSwift.cpp b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridTestObjectSwiftKotlinSpecSwift.cpp index d453f2e164..791ed72b39 100644 --- a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridTestObjectSwiftKotlinSpecSwift.cpp +++ b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridTestObjectSwiftKotlinSpecSwift.cpp @@ -216,8 +216,8 @@ namespace margelo::nitro::test { } swift::String HybridTestObjectSwiftKotlinSpecSwift::addStrings(const swift::String& a, const swift::String& b) { - auto __result = withSwiftResult([&](void* __outResult) { - return _swiftPart.addStrings(a, b, __outResult); + auto __result = receiveSwiftResult([&](const void* __onResult) { + return _swiftPart.addStrings(a, b, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -241,8 +241,8 @@ namespace margelo::nitro::test { } swift::Array HybridTestObjectSwiftKotlinSpecSwift::bounceStrings(const swift::Array& array) { - auto __result = withSwiftResult>([&](void* __outResult) { - return _swiftPart.bounceStrings(array, __outResult); + auto __result = receiveSwiftResult>([&](const void* __onResult) { + return _swiftPart.bounceStrings(array, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -251,8 +251,8 @@ namespace margelo::nitro::test { } swift::Array HybridTestObjectSwiftKotlinSpecSwift::bounceNumbers(const swift::Array& array) { - auto __result = withSwiftResult>([&](void* __outResult) { - return _swiftPart.bounceNumbers(array, __outResult); + auto __result = receiveSwiftResult>([&](const void* __onResult) { + return _swiftPart.bounceNumbers(array, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -261,8 +261,8 @@ namespace margelo::nitro::test { } swift::Array<::NitroTest::Person> HybridTestObjectSwiftKotlinSpecSwift::bounceStructs(const swift::Array<::NitroTest::Person>& array) { - auto __result = withSwiftResult>([&](void* __outResult) { - return _swiftPart.bounceStructs(array, __outResult); + auto __result = receiveSwiftResult>([&](const void* __onResult) { + return _swiftPart.bounceStructs(array, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -271,8 +271,8 @@ namespace margelo::nitro::test { } swift::Array> HybridTestObjectSwiftKotlinSpecSwift::bounceNestedArray(const swift::Array>& array) { - auto __result = withSwiftResult>>([&](void* __outResult) { - return _swiftPart.bounceNestedArray(array, __outResult); + auto __result = receiveSwiftResult>>([&](const void* __onResult) { + return _swiftPart.bounceNestedArray(array, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -281,8 +281,8 @@ namespace margelo::nitro::test { } ::NitroTest::PartialPerson HybridTestObjectSwiftKotlinSpecSwift::bouncePartialStruct(const ::NitroTest::PartialPerson& person) { - auto __result = withSwiftResult<::NitroTest::PartialPerson>([&](void* __outResult) { - return _swiftPart.bouncePartialStruct(person, __outResult); + auto __result = receiveSwiftResult<::NitroTest::PartialPerson>([&](const void* __onResult) { + return _swiftPart.bouncePartialStruct(person, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -291,8 +291,8 @@ namespace margelo::nitro::test { } swift::String HybridTestObjectSwiftKotlinSpecSwift::sumUpAllPassengers(const swift::Array<::NitroTest::Car>& cars) { - auto __result = withSwiftResult([&](void* __outResult) { - return _swiftPart.sumUpAllPassengers(cars, __outResult); + auto __result = receiveSwiftResult([&](const void* __onResult) { + return _swiftPart.sumUpAllPassengers(cars, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -301,8 +301,8 @@ namespace margelo::nitro::test { } swift::Array<::NitroTest::Powertrain> HybridTestObjectSwiftKotlinSpecSwift::bounceEnums(const swift::Array<::NitroTest::Powertrain>& array) { - auto __result = withSwiftResult>([&](void* __outResult) { - return _swiftPart.bounceEnums(array, __outResult); + auto __result = receiveSwiftResult>([&](const void* __onResult) { + return _swiftPart.bounceEnums(array, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -321,8 +321,8 @@ namespace margelo::nitro::test { swift::Array<::NitroTest::Powertrain> HybridTestObjectSwiftKotlinSpecSwift::callEnumArrayCallback(const swift::Array<::NitroTest::Powertrain>& array, const Callback<::NitroTest::SwiftContainer_swift__Array___NitroTest__Powertrain_(const ::NitroTest::SwiftContainer_swift__Array___NitroTest__Powertrain_&)>& callback) { auto __result = ([&](const void* callback) { - return withSwiftResult>([&](void* __outResult) { - return _swiftPart.callEnumArrayCallback(array, callback, __outResult); + return receiveSwiftResult>([&](const void* __onResult) { + return _swiftPart.callEnumArrayCallback(array, callback, __onResult); }); })(std::addressof(callback)); if (__result.hasError()) [[unlikely]] { @@ -367,8 +367,8 @@ namespace margelo::nitro::test { swift::Array>> HybridTestObjectSwiftKotlinSpecSwift::callNestedStructCallback(const swift::Array>>& value, const Callback<::NitroTest::SwiftContainer_swift__Array_swift__Array_swift__Optional___NitroTest__Person___(const ::NitroTest::SwiftContainer_swift__Array_swift__Array_swift__Optional___NitroTest__Person___&)>& callback) { auto __result = ([&](const void* callback) { - return withSwiftResult>>>([&](void* __outResult) { - return _swiftPart.callNestedStructCallback(value, callback, __outResult); + return receiveSwiftResult>>>([&](const void* __onResult) { + return _swiftPart.callNestedStructCallback(value, callback, __onResult); }); })(std::addressof(callback)); if (__result.hasError()) [[unlikely]] { @@ -378,8 +378,8 @@ namespace margelo::nitro::test { } swift::Array<::NitroTest::HybridChildSpec_cxx> HybridTestObjectSwiftKotlinSpecSwift::bounceHybridObjects(const swift::Array<::NitroTest::HybridChildSpec_cxx>& array) { - auto __result = withSwiftResult>([&](void* __outResult) { - return _swiftPart.bounceHybridObjects(array, __outResult); + auto __result = receiveSwiftResult>([&](const void* __onResult) { + return _swiftPart.bounceHybridObjects(array, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -388,8 +388,8 @@ namespace margelo::nitro::test { } swift::Array> HybridTestObjectSwiftKotlinSpecSwift::bounceFunctions(const swift::Array>& functions) { - auto __result = withSwiftResult>>([&](void* __outResult) { - return _swiftPart.bounceFunctions(functions, __outResult); + auto __result = receiveSwiftResult>>([&](const void* __onResult) { + return _swiftPart.bounceFunctions(functions, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -398,8 +398,8 @@ namespace margelo::nitro::test { } swift::Array HybridTestObjectSwiftKotlinSpecSwift::bounceMaps(const swift::Array& maps) { - auto __result = withSwiftResult>([&](void* __outResult) { - return _swiftPart.bounceMaps(maps, __outResult); + auto __result = receiveSwiftResult>([&](const void* __onResult) { + return _swiftPart.bounceMaps(maps, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -408,8 +408,8 @@ namespace margelo::nitro::test { } swift::Array> HybridTestObjectSwiftKotlinSpecSwift::bouncePromises(const swift::Array>& promises) { - auto __result = withSwiftResult>>([&](void* __outResult) { - return _swiftPart.bouncePromises(promises, __outResult); + auto __result = receiveSwiftResult>>([&](const void* __onResult) { + return _swiftPart.bouncePromises(promises, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -418,8 +418,8 @@ namespace margelo::nitro::test { } swift::Array HybridTestObjectSwiftKotlinSpecSwift::bounceArrayBuffers(const swift::Array& arrayBuffers) { - auto __result = withSwiftResult>([&](void* __outResult) { - return _swiftPart.bounceArrayBuffers(arrayBuffers, __outResult); + auto __result = receiveSwiftResult>([&](const void* __onResult) { + return _swiftPart.bounceArrayBuffers(arrayBuffers, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -428,8 +428,8 @@ namespace margelo::nitro::test { } swift::Array> HybridTestObjectSwiftKotlinSpecSwift::bounceOptionals(const swift::Array>& strings, const swift::Array>& arrayBuffers) { - auto __result = withSwiftResult>>([&](void* __outResult) { - return _swiftPart.bounceOptionals(strings, arrayBuffers, __outResult); + auto __result = receiveSwiftResult>>([&](const void* __onResult) { + return _swiftPart.bounceOptionals(strings, arrayBuffers, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -438,8 +438,8 @@ namespace margelo::nitro::test { } swift::Array<::NitroTest::Variant_NullType_String_cxx> HybridTestObjectSwiftKotlinSpecSwift::bounceNulls(const swift::Array<::NitroTest::Variant_NullType_String_cxx>& strings) { - auto __result = withSwiftResult>([&](void* __outResult) { - return _swiftPart.bounceNulls(strings, __outResult); + auto __result = receiveSwiftResult>([&](const void* __onResult) { + return _swiftPart.bounceNulls(strings, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -448,8 +448,8 @@ namespace margelo::nitro::test { } swift::Array> HybridTestObjectSwiftKotlinSpecSwift::bounceOptionalNulls(const swift::Array>& strings) { - auto __result = withSwiftResult>>([&](void* __outResult) { - return _swiftPart.bounceOptionalNulls(strings, __outResult); + auto __result = receiveSwiftResult>>([&](const void* __onResult) { + return _swiftPart.bounceOptionalNulls(strings, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -458,8 +458,8 @@ namespace margelo::nitro::test { } NitroModules::AnyJSON HybridTestObjectSwiftKotlinSpecSwift::createMap() { - auto __result = withSwiftResult([&](void* __outResult) { - return _swiftPart.createMap(__outResult); + auto __result = receiveSwiftResult([&](const void* __onResult) { + return _swiftPart.createMap(__onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -468,8 +468,8 @@ namespace margelo::nitro::test { } NitroModules::AnyJSON HybridTestObjectSwiftKotlinSpecSwift::mapRoundtrip(const NitroModules::AnyJSON& map) { - auto __result = withSwiftResult([&](void* __outResult) { - return _swiftPart.mapRoundtrip(map, __outResult); + auto __result = receiveSwiftResult([&](const void* __onResult) { + return _swiftPart.mapRoundtrip(map, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -478,8 +478,8 @@ namespace margelo::nitro::test { } swift::Array HybridTestObjectSwiftKotlinSpecSwift::getMapKeys(const NitroModules::AnyJSON& map) { - auto __result = withSwiftResult>([&](void* __outResult) { - return _swiftPart.getMapKeys(map, __outResult); + auto __result = receiveSwiftResult>([&](const void* __onResult) { + return _swiftPart.getMapKeys(map, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -488,8 +488,8 @@ namespace margelo::nitro::test { } NitroModules::AnyJSON HybridTestObjectSwiftKotlinSpecSwift::mergeMaps(const NitroModules::AnyJSON& a, const NitroModules::AnyJSON& b) { - auto __result = withSwiftResult([&](void* __outResult) { - return _swiftPart.mergeMaps(a, b, __outResult); + auto __result = receiveSwiftResult([&](const void* __onResult) { + return _swiftPart.mergeMaps(a, b, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -498,8 +498,8 @@ namespace margelo::nitro::test { } NitroModules::AnyJSON HybridTestObjectSwiftKotlinSpecSwift::copyAnyMap(const NitroModules::AnyJSON& map) { - auto __result = withSwiftResult([&](void* __outResult) { - return _swiftPart.copyAnyMap(map, __outResult); + auto __result = receiveSwiftResult([&](const void* __onResult) { + return _swiftPart.copyAnyMap(map, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -508,8 +508,8 @@ namespace margelo::nitro::test { } ::NitroTest::Record_swift__String___NitroTest__Variant_Bool_Double_cxx HybridTestObjectSwiftKotlinSpecSwift::bounceMap(const ::NitroTest::Record_swift__String___NitroTest__Variant_Bool_Double_cxx& map) { - auto __result = withSwiftResult<::NitroTest::Record_swift__String___NitroTest__Variant_Bool_Double_cxx>([&](void* __outResult) { - return _swiftPart.bounceMap(map, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Record_swift__String___NitroTest__Variant_Bool_Double_cxx>([&](const void* __onResult) { + return _swiftPart.bounceMap(map, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -518,8 +518,8 @@ namespace margelo::nitro::test { } ::NitroTest::Record_swift__String_double HybridTestObjectSwiftKotlinSpecSwift::bounceSimpleMap(const ::NitroTest::Record_swift__String_double& map) { - auto __result = withSwiftResult<::NitroTest::Record_swift__String_double>([&](void* __outResult) { - return _swiftPart.bounceSimpleMap(map, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Record_swift__String_double>([&](const void* __onResult) { + return _swiftPart.bounceSimpleMap(map, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -528,8 +528,8 @@ namespace margelo::nitro::test { } ::NitroTest::Record_swift__String_swift__Optional_swift__String_ HybridTestObjectSwiftKotlinSpecSwift::bounceOptionalMap(const ::NitroTest::Record_swift__String_swift__Optional_swift__String_& map) { - auto __result = withSwiftResult<::NitroTest::Record_swift__String_swift__Optional_swift__String_>([&](void* __outResult) { - return _swiftPart.bounceOptionalMap(map, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Record_swift__String_swift__Optional_swift__String_>([&](const void* __onResult) { + return _swiftPart.bounceOptionalMap(map, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -538,8 +538,8 @@ namespace margelo::nitro::test { } ::NitroTest::Record_swift__String___NitroTest__Variant_NullType_String_cxx HybridTestObjectSwiftKotlinSpecSwift::bounceNullMap(const ::NitroTest::Record_swift__String___NitroTest__Variant_NullType_String_cxx& map) { - auto __result = withSwiftResult<::NitroTest::Record_swift__String___NitroTest__Variant_NullType_String_cxx>([&](void* __outResult) { - return _swiftPart.bounceNullMap(map, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Record_swift__String___NitroTest__Variant_NullType_String_cxx>([&](const void* __onResult) { + return _swiftPart.bounceNullMap(map, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -548,8 +548,8 @@ namespace margelo::nitro::test { } ::NitroTest::Record_swift__String_swift__Optional___NitroTest__Variant_NullType_String_cxx_ HybridTestObjectSwiftKotlinSpecSwift::bounceOptionalNullMap(const ::NitroTest::Record_swift__String_swift__Optional___NitroTest__Variant_NullType_String_cxx_& map) { - auto __result = withSwiftResult<::NitroTest::Record_swift__String_swift__Optional___NitroTest__Variant_NullType_String_cxx_>([&](void* __outResult) { - return _swiftPart.bounceOptionalNullMap(map, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Record_swift__String_swift__Optional___NitroTest__Variant_NullType_String_cxx_>([&](const void* __onResult) { + return _swiftPart.bounceOptionalNullMap(map, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -558,8 +558,8 @@ namespace margelo::nitro::test { } ::NitroTest::Record_swift__String_swift__String HybridTestObjectSwiftKotlinSpecSwift::extractMap(const ::NitroTest::MapWrapper& mapWrapper) { - auto __result = withSwiftResult<::NitroTest::Record_swift__String_swift__String>([&](void* __outResult) { - return _swiftPart.extractMap(mapWrapper, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Record_swift__String_swift__String>([&](const void* __onResult) { + return _swiftPart.extractMap(mapWrapper, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -593,8 +593,8 @@ namespace margelo::nitro::test { } swift::String HybridTestObjectSwiftKotlinSpecSwift::tryOptionalParams(double num, bool boo, const swift::Optional& str) { - auto __result = withSwiftResult([&](void* __outResult) { - return _swiftPart.tryOptionalParams(num, boo, str, __outResult); + auto __result = receiveSwiftResult([&](const void* __onResult) { + return _swiftPart.tryOptionalParams(num, boo, str, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -603,8 +603,8 @@ namespace margelo::nitro::test { } swift::String HybridTestObjectSwiftKotlinSpecSwift::tryMiddleParam(double num, const swift::Optional& boo, const swift::String& str) { - auto __result = withSwiftResult([&](void* __outResult) { - return _swiftPart.tryMiddleParam(num, boo, str, __outResult); + auto __result = receiveSwiftResult([&](const void* __onResult) { + return _swiftPart.tryMiddleParam(num, boo, str, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -613,8 +613,8 @@ namespace margelo::nitro::test { } swift::Optional<::NitroTest::Powertrain> HybridTestObjectSwiftKotlinSpecSwift::tryOptionalEnum(const swift::Optional<::NitroTest::Powertrain>& value) { - auto __result = withSwiftResult>([&](void* __outResult) { - return _swiftPart.tryOptionalEnum(value, __outResult); + auto __result = receiveSwiftResult>([&](const void* __onResult) { + return _swiftPart.tryOptionalEnum(value, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1043,8 +1043,8 @@ namespace margelo::nitro::test { } ::NitroTest::Car HybridTestObjectSwiftKotlinSpecSwift::getCar() { - auto __result = withSwiftResult<::NitroTest::Car>([&](void* __outResult) { - return _swiftPart.getCar(__outResult); + auto __result = receiveSwiftResult<::NitroTest::Car>([&](const void* __onResult) { + return _swiftPart.getCar(__onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1069,8 +1069,8 @@ namespace margelo::nitro::test { } swift::Optional<::NitroTest::Person> HybridTestObjectSwiftKotlinSpecSwift::getDriver(const ::NitroTest::Car& car) { - auto __result = withSwiftResult>([&](void* __outResult) { - return _swiftPart.getDriver(car, __outResult); + auto __result = receiveSwiftResult>([&](const void* __onResult) { + return _swiftPart.getDriver(car, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1079,8 +1079,8 @@ namespace margelo::nitro::test { } ::NitroTest::Car HybridTestObjectSwiftKotlinSpecSwift::bounceCar(const ::NitroTest::Car& car) { - auto __result = withSwiftResult<::NitroTest::Car>([&](void* __outResult) { - return _swiftPart.bounceCar(car, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Car>([&](const void* __onResult) { + return _swiftPart.bounceCar(car, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1096,8 +1096,8 @@ namespace margelo::nitro::test { } ::NitroTest::UnsignedScalar HybridTestObjectSwiftKotlinSpecSwift::roundtripUnsignedScalar(const ::NitroTest::UnsignedScalar& value) { - auto __result = withSwiftResult<::NitroTest::UnsignedScalar>([&](void* __outResult) { - return _swiftPart.roundtripUnsignedScalar(value, __outResult); + auto __result = receiveSwiftResult<::NitroTest::UnsignedScalar>([&](const void* __onResult) { + return _swiftPart.roundtripUnsignedScalar(value, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1106,8 +1106,8 @@ namespace margelo::nitro::test { } ::NitroTest::UnsignedValues HybridTestObjectSwiftKotlinSpecSwift::roundtripUnsignedValues(const ::NitroTest::UnsignedValues& value) { - auto __result = withSwiftResult<::NitroTest::UnsignedValues>([&](void* __outResult) { - return _swiftPart.roundtripUnsignedValues(value, __outResult); + auto __result = receiveSwiftResult<::NitroTest::UnsignedValues>([&](const void* __onResult) { + return _swiftPart.roundtripUnsignedValues(value, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1116,8 +1116,8 @@ namespace margelo::nitro::test { } ::NitroTest::WrappedJsStruct HybridTestObjectSwiftKotlinSpecSwift::bounceWrappedJsStyleStruct(const ::NitroTest::WrappedJsStruct& value) { - auto __result = withSwiftResult<::NitroTest::WrappedJsStruct>([&](void* __outResult) { - return _swiftPart.bounceWrappedJsStyleStruct(value, __outResult); + auto __result = receiveSwiftResult<::NitroTest::WrappedJsStruct>([&](const void* __onResult) { + return _swiftPart.bounceWrappedJsStyleStruct(value, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1126,8 +1126,8 @@ namespace margelo::nitro::test { } ::NitroTest::OptionalWrapper HybridTestObjectSwiftKotlinSpecSwift::bounceOptionalWrapper(const ::NitroTest::OptionalWrapper& wrapper) { - auto __result = withSwiftResult<::NitroTest::OptionalWrapper>([&](void* __outResult) { - return _swiftPart.bounceOptionalWrapper(wrapper, __outResult); + auto __result = receiveSwiftResult<::NitroTest::OptionalWrapper>([&](const void* __onResult) { + return _swiftPart.bounceOptionalWrapper(wrapper, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1136,8 +1136,8 @@ namespace margelo::nitro::test { } ::NitroTest::OptionalCallback HybridTestObjectSwiftKotlinSpecSwift::bounceOptionalCallback(const ::NitroTest::OptionalCallback& value) { - auto __result = withSwiftResult<::NitroTest::OptionalCallback>([&](void* __outResult) { - return _swiftPart.bounceOptionalCallback(value, __outResult); + auto __result = receiveSwiftResult<::NitroTest::OptionalCallback>([&](const void* __onResult) { + return _swiftPart.bounceOptionalCallback(value, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1146,8 +1146,8 @@ namespace margelo::nitro::test { } swift::Optional<::NitroTest::OptionalEnumWrapper> HybridTestObjectSwiftKotlinSpecSwift::bounceOptionalEnumStruct(const swift::Optional<::NitroTest::OptionalEnumWrapper>& value) { - auto __result = withSwiftResult>([&](void* __outResult) { - return _swiftPart.bounceOptionalEnumStruct(value, __outResult); + auto __result = receiveSwiftResult>([&](const void* __onResult) { + return _swiftPart.bounceOptionalEnumStruct(value, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1221,8 +1221,8 @@ namespace margelo::nitro::test { } ::NitroTest::Variant_Double_String_cxx HybridTestObjectSwiftKotlinSpecSwift::passVariant(const ::NitroTest::Variant_Bool__Double___String__Double_String_cxx& either) { - auto __result = withSwiftResult<::NitroTest::Variant_Double_String_cxx>([&](void* __outResult) { - return _swiftPart.passVariant(either, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Variant_Double_String_cxx>([&](const void* __onResult) { + return _swiftPart.passVariant(either, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1231,8 +1231,8 @@ namespace margelo::nitro::test { } ::NitroTest::Variant_OldEnum_Bool_cxx HybridTestObjectSwiftKotlinSpecSwift::getVariantEnum(const ::NitroTest::Variant_OldEnum_Bool_cxx& variant) { - auto __result = withSwiftResult<::NitroTest::Variant_OldEnum_Bool_cxx>([&](void* __outResult) { - return _swiftPart.getVariantEnum(variant, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Variant_OldEnum_Bool_cxx>([&](const void* __onResult) { + return _swiftPart.getVariantEnum(variant, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1241,8 +1241,8 @@ namespace margelo::nitro::test { } ::NitroTest::Variant_Powertrain_Car_cxx HybridTestObjectSwiftKotlinSpecSwift::bounceVariantUnionEnum(const ::NitroTest::Variant_Powertrain_Car_cxx& variant) { - auto __result = withSwiftResult<::NitroTest::Variant_Powertrain_Car_cxx>([&](void* __outResult) { - return _swiftPart.bounceVariantUnionEnum(variant, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Variant_Powertrain_Car_cxx>([&](const void* __onResult) { + return _swiftPart.bounceVariantUnionEnum(variant, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1251,8 +1251,8 @@ namespace margelo::nitro::test { } ::NitroTest::Variant_WeirdNumbersEnum_Bool_cxx HybridTestObjectSwiftKotlinSpecSwift::getVariantWeirdNumbersEnum(const ::NitroTest::Variant_WeirdNumbersEnum_Bool_cxx& variant) { - auto __result = withSwiftResult<::NitroTest::Variant_WeirdNumbersEnum_Bool_cxx>([&](void* __outResult) { - return _swiftPart.getVariantWeirdNumbersEnum(variant, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Variant_WeirdNumbersEnum_Bool_cxx>([&](const void* __onResult) { + return _swiftPart.getVariantWeirdNumbersEnum(variant, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1261,8 +1261,8 @@ namespace margelo::nitro::test { } ::NitroTest::Variant_Person_Car_cxx HybridTestObjectSwiftKotlinSpecSwift::getVariantObjects(const ::NitroTest::Variant_Person_Car_cxx& variant) { - auto __result = withSwiftResult<::NitroTest::Variant_Person_Car_cxx>([&](void* __outResult) { - return _swiftPart.getVariantObjects(variant, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Variant_Person_Car_cxx>([&](const void* __onResult) { + return _swiftPart.getVariantObjects(variant, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1271,8 +1271,8 @@ namespace margelo::nitro::test { } ::NitroTest::NamedVariant_cxx HybridTestObjectSwiftKotlinSpecSwift::passNamedVariant(const ::NitroTest::NamedVariant_cxx& variant) { - auto __result = withSwiftResult<::NitroTest::NamedVariant_cxx>([&](void* __outResult) { - return _swiftPart.passNamedVariant(variant, __outResult); + auto __result = receiveSwiftResult<::NitroTest::NamedVariant_cxx>([&](const void* __onResult) { + return _swiftPart.passNamedVariant(variant, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1281,8 +1281,8 @@ namespace margelo::nitro::test { } ::NitroTest::Variant__any_HybridBaseSpec__OptionalWrapper_cxx HybridTestObjectSwiftKotlinSpecSwift::passAllEmptyObjectVariant(const ::NitroTest::Variant__any_HybridBaseSpec__OptionalWrapper_cxx& variant) { - auto __result = withSwiftResult<::NitroTest::Variant__any_HybridBaseSpec__OptionalWrapper_cxx>([&](void* __outResult) { - return _swiftPart.passAllEmptyObjectVariant(variant, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Variant__any_HybridBaseSpec__OptionalWrapper_cxx>([&](const void* __onResult) { + return _swiftPart.passAllEmptyObjectVariant(variant, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1291,8 +1291,8 @@ namespace margelo::nitro::test { } ::NitroTest::CoreTypesVariant_cxx HybridTestObjectSwiftKotlinSpecSwift::bounceComplexVariant(const ::NitroTest::CoreTypesVariant_cxx& variant) { - auto __result = withSwiftResult<::NitroTest::CoreTypesVariant_cxx>([&](void* __outResult) { - return _swiftPart.bounceComplexVariant(variant, __outResult); + auto __result = receiveSwiftResult<::NitroTest::CoreTypesVariant_cxx>([&](const void* __onResult) { + return _swiftPart.bounceComplexVariant(variant, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1437,8 +1437,8 @@ namespace margelo::nitro::test { } ::NitroTest::ExternalObjectStruct HybridTestObjectSwiftKotlinSpecSwift::bounceExternalStruct(const ::NitroTest::ExternalObjectStruct& externalStruct) { - auto __result = withSwiftResult<::NitroTest::ExternalObjectStruct>([&](void* __outResult) { - return _swiftPart.bounceExternalStruct(externalStruct, __outResult); + auto __result = receiveSwiftResult<::NitroTest::ExternalObjectStruct>([&](const void* __onResult) { + return _swiftPart.bounceExternalStruct(externalStruct, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1447,8 +1447,8 @@ namespace margelo::nitro::test { } ::NitroTest::StringOrExternal_cxx HybridTestObjectSwiftKotlinSpecSwift::bounceExternalVariant(const ::NitroTest::StringOrExternal_cxx& variant) { - auto __result = withSwiftResult<::NitroTest::StringOrExternal_cxx>([&](void* __outResult) { - return _swiftPart.bounceExternalVariant(variant, __outResult); + auto __result = receiveSwiftResult<::NitroTest::StringOrExternal_cxx>([&](const void* __onResult) { + return _swiftPart.bounceExternalVariant(variant, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1467,8 +1467,8 @@ namespace margelo::nitro::test { } ::NitroTest::CppOnlyValue HybridTestObjectSwiftKotlinSpecSwift::bounceCppOnlyValue(const ::NitroTest::CppOnlyValue& value) { - auto __result = withSwiftResult<::NitroTest::CppOnlyValue>([&](void* __outResult) { - return _swiftPart.bounceCppOnlyValue(value, __outResult); + auto __result = receiveSwiftResult<::NitroTest::CppOnlyValue>([&](const void* __onResult) { + return _swiftPart.bounceCppOnlyValue(value, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1495,8 +1495,8 @@ namespace margelo::nitro::test { } ::NitroTest::Variant__any_HybridTestObjectSwiftKotlinSpec__Person_cxx HybridTestObjectSwiftKotlinSpecSwift::getVariantHybrid(const ::NitroTest::Variant__any_HybridTestObjectSwiftKotlinSpec__Person_cxx& variant) { - auto __result = withSwiftResult<::NitroTest::Variant__any_HybridTestObjectSwiftKotlinSpec__Person_cxx>([&](void* __outResult) { - return _swiftPart.getVariantHybrid(variant, __outResult); + auto __result = receiveSwiftResult<::NitroTest::Variant__any_HybridTestObjectSwiftKotlinSpec__Person_cxx>([&](const void* __onResult) { + return _swiftPart.getVariantHybrid(variant, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1533,8 +1533,8 @@ namespace margelo::nitro::test { } swift::String HybridTestObjectSwiftKotlinSpecSwift::staticConcat(const swift::String& a, const swift::String& b) { - auto __result = withSwiftResult([&](void* __outResult) { - return ::NitroTest::HybridTestObjectSwiftKotlinSpec_cxx::staticConcat(a, b, __outResult); + auto __result = receiveSwiftResult([&](const void* __onResult) { + return ::NitroTest::HybridTestObjectSwiftKotlinSpec_cxx::staticConcat(a, b, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); @@ -1543,8 +1543,8 @@ namespace margelo::nitro::test { } ::NitroTest::StaticPoint HybridTestObjectSwiftKotlinSpecSwift::staticBouncePoint(const ::NitroTest::StaticPoint& point) { - auto __result = withSwiftResult<::NitroTest::StaticPoint>([&](void* __outResult) { - return ::NitroTest::HybridTestObjectSwiftKotlinSpec_cxx::staticBouncePoint(point, __outResult); + auto __result = receiveSwiftResult<::NitroTest::StaticPoint>([&](const void* __onResult) { + return ::NitroTest::HybridTestObjectSwiftKotlinSpec_cxx::staticBouncePoint(point, __onResult); }); if (__result.hasError()) [[unlikely]] { std::rethrow_exception(__result.error()); diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridBaseSpec_cxx.swift b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridBaseSpec_cxx.swift index ae81af093d..9aff38ba5a 100644 --- a/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridBaseSpec_cxx.swift +++ b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridBaseSpec_cxx.swift @@ -7,6 +7,7 @@ internal import NitroModules internal import CxxStdlib internal import NitroTestAppleCxx +internal import NitroModulesAppleCxx /** * A class implementation that bridges HybridBaseSpec over to C++. @@ -131,20 +132,24 @@ open class HybridBaseSpec_cxx { // Methods - public final func bounceSize(size: Size, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceSize(size: Size, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceSize(size: size) - __outResult.assumingMemoryBound(to: Size.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceSizeUnit(unit: SizeUnit, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceSizeUnit(unit: SizeUnit, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceSizeUnit(unit: unit) - __outResult.assumingMemoryBound(to: SizeUnit.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridChildSpec_cxx.swift b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridChildSpec_cxx.swift index 5c80850bea..e05fd56eb5 100644 --- a/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridChildSpec_cxx.swift +++ b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridChildSpec_cxx.swift @@ -7,6 +7,7 @@ internal import NitroModules internal import CxxStdlib internal import NitroTestAppleCxx +internal import NitroModulesAppleCxx /** * A class implementation that bridges HybridChildSpec over to C++. @@ -137,10 +138,12 @@ open class HybridChildSpec_cxx: HybridBaseSpec_cxx { // Methods - public final func bounceVariant(variant: NamedVariant_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceVariant(variant: NamedVariant_cxx, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceVariant(variant: variant.value) - __outResult.assumingMemoryBound(to: NamedVariant_cxx.self).initialize(to: NamedVariant_cxx(value)) + withUnsafePointer(to: NamedVariant_cxx(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridPlatformObjectSpec_cxx.swift b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridPlatformObjectSpec_cxx.swift index ce70df467c..269fa48014 100644 --- a/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridPlatformObjectSpec_cxx.swift +++ b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridPlatformObjectSpec_cxx.swift @@ -8,6 +8,7 @@ internal import NitroModules internal import CxxStdlib internal import NitroTestAppleCxx internal import NitroTestExternal +internal import NitroModulesAppleCxx /** * A class implementation that bridges HybridPlatformObjectSpec over to C++. @@ -130,10 +131,12 @@ public final class HybridPlatformObjectSpec_cxx { // Methods - public final func getOSVersion(__outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func getOSVersion(__onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.getOSVersion() - __outResult.assumingMemoryBound(to: String.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift index db8c617b9c..b4d27e4263 100644 --- a/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift +++ b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift @@ -8,6 +8,7 @@ public import NitroModules internal import CxxStdlib internal import NitroTestAppleCxx public import NitroTestExternal +internal import NitroModulesAppleCxx /** * A class implementation that bridges HybridTestObjectSwiftKotlinSpec over to C++. @@ -352,10 +353,12 @@ public final class HybridTestObjectSwiftKotlinSpec_cxx { } } - public final func addStrings(a: String, b: String, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func addStrings(a: String, b: String, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.addStrings(a: a, b: b) - __outResult.assumingMemoryBound(to: String.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) @@ -380,70 +383,84 @@ public final class HybridTestObjectSwiftKotlinSpec_cxx { } } - public final func bounceStrings(array: [String], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceStrings(array: [String], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceStrings(array: array) - __outResult.assumingMemoryBound(to: [String].self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceNumbers(array: [Double], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceNumbers(array: [Double], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceNumbers(array: array) - __outResult.assumingMemoryBound(to: [Double].self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceStructs(array: [Person], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceStructs(array: [Person], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceStructs(array: array) - __outResult.assumingMemoryBound(to: [Person].self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceNestedArray(array: [[Person]], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceNestedArray(array: [[Person]], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceNestedArray(array: array) - __outResult.assumingMemoryBound(to: [[Person]].self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bouncePartialStruct(person: PartialPerson, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bouncePartialStruct(person: PartialPerson, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bouncePartialStruct(person: person) - __outResult.assumingMemoryBound(to: PartialPerson.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func sumUpAllPassengers(cars: [Car], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func sumUpAllPassengers(cars: [Car], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.sumUpAllPassengers(cars: cars) - __outResult.assumingMemoryBound(to: String.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceEnums(array: [Powertrain], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceEnums(array: [Powertrain], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceEnums(array: array) - __outResult.assumingMemoryBound(to: [Powertrain].self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) @@ -459,10 +476,12 @@ public final class HybridTestObjectSwiftKotlinSpec_cxx { } } - public final func callEnumArrayCallback(array: [Powertrain], callback: UnsafeRawPointer, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func callEnumArrayCallback(array: [Powertrain], callback: UnsafeRawPointer, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.callEnumArrayCallback(array: array, callback: callback.load(as: margelo.nitro.test.swift_bridge.Callback___NitroTest__SwiftContainer_swift__Array___NitroTest__Powertrain____NitroTest__SwiftContainer_swift__Array___NitroTest__Powertrain_.self)) - __outResult.assumingMemoryBound(to: [Powertrain].self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) @@ -499,200 +518,240 @@ public final class HybridTestObjectSwiftKotlinSpec_cxx { } } - public final func callNestedStructCallback(value: [[Person?]], callback: UnsafeRawPointer, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func callNestedStructCallback(value: [[Person?]], callback: UnsafeRawPointer, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.callNestedStructCallback(value: value, callback: callback.load(as: margelo.nitro.test.swift_bridge.Callback___NitroTest__SwiftContainer_swift__Array_swift__Array_swift__Optional___NitroTest__Person______NitroTest__SwiftContainer_swift__Array_swift__Array_swift__Optional___NitroTest__Person___.self)) - __outResult.assumingMemoryBound(to: [[Person?]].self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceHybridObjects(array: [HybridChildSpec_cxx], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceHybridObjects(array: [HybridChildSpec_cxx], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceHybridObjects(array: array.map { $0.getHybridChildSpec() }) - __outResult.assumingMemoryBound(to: [HybridChildSpec_cxx].self).initialize(to: value.map { $0.getCxxWrapper() }) + withUnsafePointer(to: value.map { $0.getCxxWrapper() }) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceFunctions(functions: [margelo.nitro.test.swift_bridge.Callback_void], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceFunctions(functions: [margelo.nitro.test.swift_bridge.Callback_void], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceFunctions(functions: functions.map { $0 }) - __outResult.assumingMemoryBound(to: [margelo.nitro.test.swift_bridge.Callback_void].self).initialize(to: value.map { $0.toCpp() }) + withUnsafePointer(to: value.map { $0.toCpp() }) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceMaps(maps: [AnyJSON], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceMaps(maps: [AnyJSON], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceMaps(maps: maps) - __outResult.assumingMemoryBound(to: [AnyJSON].self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bouncePromises(promises: [margelo.nitro.test.swift_bridge.Promise_double], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bouncePromises(promises: [margelo.nitro.test.swift_bridge.Promise_double], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bouncePromises(promises: promises.map { $0 }) - __outResult.assumingMemoryBound(to: [margelo.nitro.test.swift_bridge.Promise_double].self).initialize(to: value.map { $0.toCpp() }) + withUnsafePointer(to: value.map { $0.toCpp() }) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceArrayBuffers(arrayBuffers: [ArrayBuffer], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceArrayBuffers(arrayBuffers: [ArrayBuffer], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceArrayBuffers(arrayBuffers: arrayBuffers) - __outResult.assumingMemoryBound(to: [ArrayBuffer].self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceOptionals(strings: [String?], arrayBuffers: [ArrayBuffer?], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceOptionals(strings: [String?], arrayBuffers: [ArrayBuffer?], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceOptionals(strings: strings, arrayBuffers: arrayBuffers) - __outResult.assumingMemoryBound(to: [String?].self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceNulls(strings: [Variant_NullType_String_cxx], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceNulls(strings: [Variant_NullType_String_cxx], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceNulls(strings: strings.map { $0.value }) - __outResult.assumingMemoryBound(to: [Variant_NullType_String_cxx].self).initialize(to: value.map { Variant_NullType_String_cxx($0) }) + withUnsafePointer(to: value.map { Variant_NullType_String_cxx($0) }) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceOptionalNulls(strings: [Variant_NullType_String_cxx?], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceOptionalNulls(strings: [Variant_NullType_String_cxx?], __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceOptionalNulls(strings: strings.map { $0.map { $0.value } }) - __outResult.assumingMemoryBound(to: [Variant_NullType_String_cxx?].self).initialize(to: value.map { $0.map { Variant_NullType_String_cxx($0) } }) + withUnsafePointer(to: value.map { $0.map { Variant_NullType_String_cxx($0) } }) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func createMap(__outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func createMap(__onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.createMap() - __outResult.assumingMemoryBound(to: AnyJSON.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func mapRoundtrip(map: AnyJSON, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func mapRoundtrip(map: AnyJSON, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.mapRoundtrip(map: map) - __outResult.assumingMemoryBound(to: AnyJSON.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func getMapKeys(map: AnyJSON, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func getMapKeys(map: AnyJSON, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.getMapKeys(map: map) - __outResult.assumingMemoryBound(to: [String].self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func mergeMaps(a: AnyJSON, b: AnyJSON, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func mergeMaps(a: AnyJSON, b: AnyJSON, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.mergeMaps(a: a, b: b) - __outResult.assumingMemoryBound(to: AnyJSON.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func copyAnyMap(map: AnyJSON, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func copyAnyMap(map: AnyJSON, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.copyAnyMap(map: map) - __outResult.assumingMemoryBound(to: AnyJSON.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceMap(map: Record_swift__String___NitroTest__Variant_Bool_Double_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceMap(map: Record_swift__String___NitroTest__Variant_Bool_Double_cxx, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceMap(map: map.dictionary) - __outResult.assumingMemoryBound(to: Record_swift__String___NitroTest__Variant_Bool_Double_cxx.self).initialize(to: Record_swift__String___NitroTest__Variant_Bool_Double_cxx(value)) + withUnsafePointer(to: Record_swift__String___NitroTest__Variant_Bool_Double_cxx(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceSimpleMap(map: Record_swift__String_double, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceSimpleMap(map: Record_swift__String_double, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceSimpleMap(map: map.dictionary) - __outResult.assumingMemoryBound(to: Record_swift__String_double.self).initialize(to: Record_swift__String_double(value)) + withUnsafePointer(to: Record_swift__String_double(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceOptionalMap(map: Record_swift__String_swift__Optional_swift__String_, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceOptionalMap(map: Record_swift__String_swift__Optional_swift__String_, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceOptionalMap(map: map.dictionary) - __outResult.assumingMemoryBound(to: Record_swift__String_swift__Optional_swift__String_.self).initialize(to: Record_swift__String_swift__Optional_swift__String_(value)) + withUnsafePointer(to: Record_swift__String_swift__Optional_swift__String_(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceNullMap(map: Record_swift__String___NitroTest__Variant_NullType_String_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceNullMap(map: Record_swift__String___NitroTest__Variant_NullType_String_cxx, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceNullMap(map: map.dictionary) - __outResult.assumingMemoryBound(to: Record_swift__String___NitroTest__Variant_NullType_String_cxx.self).initialize(to: Record_swift__String___NitroTest__Variant_NullType_String_cxx(value)) + withUnsafePointer(to: Record_swift__String___NitroTest__Variant_NullType_String_cxx(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceOptionalNullMap(map: Record_swift__String_swift__Optional___NitroTest__Variant_NullType_String_cxx_, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceOptionalNullMap(map: Record_swift__String_swift__Optional___NitroTest__Variant_NullType_String_cxx_, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceOptionalNullMap(map: map.dictionary) - __outResult.assumingMemoryBound(to: Record_swift__String_swift__Optional___NitroTest__Variant_NullType_String_cxx_.self).initialize(to: Record_swift__String_swift__Optional___NitroTest__Variant_NullType_String_cxx_(value)) + withUnsafePointer(to: Record_swift__String_swift__Optional___NitroTest__Variant_NullType_String_cxx_(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func extractMap(mapWrapper: MapWrapper, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func extractMap(mapWrapper: MapWrapper, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.extractMap(mapWrapper: mapWrapper) - __outResult.assumingMemoryBound(to: Record_swift__String_swift__String.self).initialize(to: Record_swift__String_swift__String(value)) + withUnsafePointer(to: Record_swift__String_swift__String(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) @@ -727,30 +786,36 @@ public final class HybridTestObjectSwiftKotlinSpec_cxx { } } - public final func tryOptionalParams(num: Double, boo: Bool, str: String?, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func tryOptionalParams(num: Double, boo: Bool, str: String?, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.tryOptionalParams(num: num, boo: boo, str: str) - __outResult.assumingMemoryBound(to: String.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func tryMiddleParam(num: Double, boo: Bool?, str: String, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func tryMiddleParam(num: Double, boo: Bool?, str: String, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.tryMiddleParam(num: num, boo: boo, str: str) - __outResult.assumingMemoryBound(to: String.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func tryOptionalEnum(value: Powertrain?, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func tryOptionalEnum(value: Powertrain?, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.tryOptionalEnum(value: value) - __outResult.assumingMemoryBound(to: Powertrain?.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) @@ -1154,10 +1219,12 @@ public final class HybridTestObjectSwiftKotlinSpec_cxx { } } - public final func getCar(__outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func getCar(__onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.getCar() - __outResult.assumingMemoryBound(to: Car.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) @@ -1182,20 +1249,24 @@ public final class HybridTestObjectSwiftKotlinSpec_cxx { } } - public final func getDriver(car: Car, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func getDriver(car: Car, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.getDriver(car: car) - __outResult.assumingMemoryBound(to: Person?.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceCar(car: Car, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceCar(car: Car, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceCar(car: car) - __outResult.assumingMemoryBound(to: Car.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) @@ -1211,60 +1282,72 @@ public final class HybridTestObjectSwiftKotlinSpec_cxx { } } - public final func roundtripUnsignedScalar(value: UnsignedScalar, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func roundtripUnsignedScalar(value: UnsignedScalar, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.roundtripUnsignedScalar(value: value) - __outResult.assumingMemoryBound(to: UnsignedScalar.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func roundtripUnsignedValues(value: UnsignedValues, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func roundtripUnsignedValues(value: UnsignedValues, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.roundtripUnsignedValues(value: value) - __outResult.assumingMemoryBound(to: UnsignedValues.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceWrappedJsStyleStruct(value: WrappedJsStruct, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceWrappedJsStyleStruct(value: WrappedJsStruct, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceWrappedJsStyleStruct(value: value) - __outResult.assumingMemoryBound(to: WrappedJsStruct.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceOptionalWrapper(wrapper: OptionalWrapper, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceOptionalWrapper(wrapper: OptionalWrapper, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceOptionalWrapper(wrapper: wrapper) - __outResult.assumingMemoryBound(to: OptionalWrapper.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceOptionalCallback(value: OptionalCallback, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceOptionalCallback(value: OptionalCallback, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceOptionalCallback(value: value) - __outResult.assumingMemoryBound(to: OptionalCallback.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceOptionalEnumStruct(value: OptionalEnumWrapper?, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceOptionalEnumStruct(value: OptionalEnumWrapper?, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceOptionalEnumStruct(value: value) - __outResult.assumingMemoryBound(to: OptionalEnumWrapper?.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) @@ -1344,80 +1427,96 @@ public final class HybridTestObjectSwiftKotlinSpec_cxx { } } - public final func passVariant(either: Variant_Bool__Double___String__Double_String_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func passVariant(either: Variant_Bool__Double___String__Double_String_cxx, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.passVariant(either: either.value) - __outResult.assumingMemoryBound(to: Variant_Double_String_cxx.self).initialize(to: Variant_Double_String_cxx(value)) + withUnsafePointer(to: Variant_Double_String_cxx(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func getVariantEnum(variant: Variant_OldEnum_Bool_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func getVariantEnum(variant: Variant_OldEnum_Bool_cxx, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.getVariantEnum(variant: variant.value) - __outResult.assumingMemoryBound(to: Variant_OldEnum_Bool_cxx.self).initialize(to: Variant_OldEnum_Bool_cxx(value)) + withUnsafePointer(to: Variant_OldEnum_Bool_cxx(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceVariantUnionEnum(variant: Variant_Powertrain_Car_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceVariantUnionEnum(variant: Variant_Powertrain_Car_cxx, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceVariantUnionEnum(variant: variant.value) - __outResult.assumingMemoryBound(to: Variant_Powertrain_Car_cxx.self).initialize(to: Variant_Powertrain_Car_cxx(value)) + withUnsafePointer(to: Variant_Powertrain_Car_cxx(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func getVariantWeirdNumbersEnum(variant: Variant_WeirdNumbersEnum_Bool_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func getVariantWeirdNumbersEnum(variant: Variant_WeirdNumbersEnum_Bool_cxx, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.getVariantWeirdNumbersEnum(variant: variant.value) - __outResult.assumingMemoryBound(to: Variant_WeirdNumbersEnum_Bool_cxx.self).initialize(to: Variant_WeirdNumbersEnum_Bool_cxx(value)) + withUnsafePointer(to: Variant_WeirdNumbersEnum_Bool_cxx(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func getVariantObjects(variant: Variant_Person_Car_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func getVariantObjects(variant: Variant_Person_Car_cxx, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.getVariantObjects(variant: variant.value) - __outResult.assumingMemoryBound(to: Variant_Person_Car_cxx.self).initialize(to: Variant_Person_Car_cxx(value)) + withUnsafePointer(to: Variant_Person_Car_cxx(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func passNamedVariant(variant: NamedVariant_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func passNamedVariant(variant: NamedVariant_cxx, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.passNamedVariant(variant: variant.value) - __outResult.assumingMemoryBound(to: NamedVariant_cxx.self).initialize(to: NamedVariant_cxx(value)) + withUnsafePointer(to: NamedVariant_cxx(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func passAllEmptyObjectVariant(variant: Variant__any_HybridBaseSpec__OptionalWrapper_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func passAllEmptyObjectVariant(variant: Variant__any_HybridBaseSpec__OptionalWrapper_cxx, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.passAllEmptyObjectVariant(variant: variant.value) - __outResult.assumingMemoryBound(to: Variant__any_HybridBaseSpec__OptionalWrapper_cxx.self).initialize(to: Variant__any_HybridBaseSpec__OptionalWrapper_cxx(value)) + withUnsafePointer(to: Variant__any_HybridBaseSpec__OptionalWrapper_cxx(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceComplexVariant(variant: CoreTypesVariant_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceComplexVariant(variant: CoreTypesVariant_cxx, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceComplexVariant(variant: variant.value) - __outResult.assumingMemoryBound(to: CoreTypesVariant_cxx.self).initialize(to: CoreTypesVariant_cxx(value)) + withUnsafePointer(to: CoreTypesVariant_cxx(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) @@ -1570,20 +1669,24 @@ public final class HybridTestObjectSwiftKotlinSpec_cxx { } } - public final func bounceExternalStruct(externalStruct: ExternalObjectStruct, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceExternalStruct(externalStruct: ExternalObjectStruct, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceExternalStruct(externalStruct: externalStruct) - __outResult.assumingMemoryBound(to: ExternalObjectStruct.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public final func bounceExternalVariant(variant: StringOrExternal_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceExternalVariant(variant: StringOrExternal_cxx, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceExternalVariant(variant: variant.value) - __outResult.assumingMemoryBound(to: StringOrExternal_cxx.self).initialize(to: StringOrExternal_cxx(value)) + withUnsafePointer(to: StringOrExternal_cxx(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) @@ -1599,10 +1702,12 @@ public final class HybridTestObjectSwiftKotlinSpec_cxx { } } - public final func bounceCppOnlyValue(value: CppOnlyValue, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func bounceCppOnlyValue(value: CppOnlyValue, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.bounceCppOnlyValue(value: value) - __outResult.assumingMemoryBound(to: CppOnlyValue.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) @@ -1628,10 +1733,12 @@ public final class HybridTestObjectSwiftKotlinSpec_cxx { } } - public final func getVariantHybrid(variant: Variant__any_HybridTestObjectSwiftKotlinSpec__Person_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public final func getVariantHybrid(variant: Variant__any_HybridTestObjectSwiftKotlinSpec__Person_cxx, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try __implementation.getVariantHybrid(variant: variant.value) - __outResult.assumingMemoryBound(to: Variant__any_HybridTestObjectSwiftKotlinSpec__Person_cxx.self).initialize(to: Variant__any_HybridTestObjectSwiftKotlinSpec__Person_cxx(value)) + withUnsafePointer(to: Variant__any_HybridTestObjectSwiftKotlinSpec__Person_cxx(value)) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) @@ -1669,20 +1776,24 @@ public final class HybridTestObjectSwiftKotlinSpec_cxx { } } - public class func staticConcat(a: String, b: String, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public class func staticConcat(a: String, b: String, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try HybridTestObjectSwift.staticConcat(a: a, b: b) - __outResult.assumingMemoryBound(to: String.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp()) } } - public class func staticBouncePoint(point: StaticPoint, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void { + public class func staticBouncePoint(point: StaticPoint, __onResult: UnsafeRawPointer) -> bridge.Result_void { do { let value = try HybridTestObjectSwift.staticBouncePoint(point: point) - __outResult.assumingMemoryBound(to: StaticPoint.self).initialize(to: value) + withUnsafePointer(to: value) { pointer in + margelo.nitro.SwiftResultConsumer.consume(__onResult, UnsafeRawPointer(pointer)) + } return bridge.Result_void.withValue() } catch { return bridge.Result_void.withError(error.toCpp())