Print non-cloneable ownership pass arguments everywhere and deprecate associated calls (most places).

arik-so · arik-so · commit 744ed6bae971 · 2021-08-31T14:09:01.000-07:00
diff --git a/bindings/LDK/Bindings.swift b/bindings/LDK/Bindings.swift
@@ -3938,12 +3938,11 @@ public class Bindings {
 }
 			
 	}
-	
-/// Non-cloneable types passed by ownership. Here be dragons!
+	#warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
 public class func swift_C2Tuple_BlockHashChannelManagerZ_read(ser: [UInt8], arg: ChannelManagerReadArgs) -> Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
 		
-				print("DANGER! Non-cloneable types passed by ownership. Affected arguments: [arg: ChannelManagerReadArgs (1)]")
-
+				
 						let serWrapper = Bindings.new_LDKu8sliceWrapper(array: ser)
 						defer {
 							serWrapper.noOpRetain()
diff --git a/bindings/LDK/results/Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ.swift b/bindings/LDK/results/Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ.swift
@@ -52,7 +52,9 @@ public class Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ: NativeTypeWrap
 				return nil
 			}
 			
-    public class func ok(o: C2Tuple_BlockHashChannelManagerZ) -> Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public class func ok(o: C2Tuple_BlockHashChannelManagerZ) -> Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
     	
         return Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(pointer: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o.cOpaqueStruct!));
     }
diff --git a/bindings/LDK/results/Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.swift b/bindings/LDK/results/Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.swift
@@ -52,7 +52,9 @@ public class Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ: NativeTypeWrap
 				return nil
 			}
 			
-    public class func ok(o: C2Tuple_BlockHashChannelMonitorZ) -> Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public class func ok(o: C2Tuple_BlockHashChannelMonitorZ) -> Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
     	
         return Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(pointer: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o.cOpaqueStruct!));
     }
diff --git a/bindings/LDK/results/Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ.swift b/bindings/LDK/results/Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ.swift
@@ -62,7 +62,9 @@ public class Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ: NativeTypeWrap
         return Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(pointer: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(oWrapper.dangle().cOpaqueStruct!));
     }
 
-    public class func err(e: LDKIOError) -> Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public class func err(e: LDKIOError) -> Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
     	
         return Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(pointer: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(e));
     }
diff --git a/bindings/LDK/results/Result_NoneErrorZ.swift b/bindings/LDK/results/Result_NoneErrorZ.swift
@@ -50,7 +50,9 @@ public class Result_NoneErrorZ: NativeTypeWrapper {
         return Result_NoneErrorZ(pointer: CResult_NoneErrorZ_ok());
     }
 
-    public class func err(e: LDKIOError) -> Result_NoneErrorZ {
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public class func err(e: LDKIOError) -> Result_NoneErrorZ {
     	
         return Result_NoneErrorZ(pointer: CResult_NoneErrorZ_err(e));
     }
diff --git a/bindings/LDK/results/Result_PayeePubKeyErrorZ.swift b/bindings/LDK/results/Result_PayeePubKeyErrorZ.swift
@@ -57,7 +57,9 @@ public class Result_PayeePubKeyErrorZ: NativeTypeWrapper {
         return Result_PayeePubKeyErrorZ(pointer: CResult_PayeePubKeyErrorZ_ok(o.danglingClone().cOpaqueStruct!));
     }
 
-    public class func err(e: LDKSecp256k1Error) -> Result_PayeePubKeyErrorZ {
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public class func err(e: LDKSecp256k1Error) -> Result_PayeePubKeyErrorZ {
     	
         return Result_PayeePubKeyErrorZ(pointer: CResult_PayeePubKeyErrorZ_err(e));
     }
diff --git a/bindings/LDK/results/Result_PublicKeyErrorZ.swift b/bindings/LDK/results/Result_PublicKeyErrorZ.swift
@@ -57,7 +57,9 @@ public class Result_PublicKeyErrorZ: NativeTypeWrapper {
         return Result_PublicKeyErrorZ(pointer: CResult_PublicKeyErrorZ_ok(Bindings.new_LDKPublicKey(array: o)));
     }
 
-    public class func err(e: LDKSecp256k1Error) -> Result_PublicKeyErrorZ {
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public class func err(e: LDKSecp256k1Error) -> Result_PublicKeyErrorZ {
     	
         return Result_PublicKeyErrorZ(pointer: CResult_PublicKeyErrorZ_err(e));
     }
diff --git a/bindings/LDK/results/Result_SecretKeyErrorZ.swift b/bindings/LDK/results/Result_SecretKeyErrorZ.swift
@@ -57,7 +57,9 @@ public class Result_SecretKeyErrorZ: NativeTypeWrapper {
         return Result_SecretKeyErrorZ(pointer: CResult_SecretKeyErrorZ_ok(Bindings.new_LDKSecretKey(array: o)));
     }
 
-    public class func err(e: LDKSecp256k1Error) -> Result_SecretKeyErrorZ {
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public class func err(e: LDKSecp256k1Error) -> Result_SecretKeyErrorZ {
     	
         return Result_SecretKeyErrorZ(pointer: CResult_SecretKeyErrorZ_err(e));
     }
diff --git a/bindings/LDK/results/Result_ShutdownScriptInvalidShutdownScriptZ.swift b/bindings/LDK/results/Result_ShutdownScriptInvalidShutdownScriptZ.swift
@@ -57,7 +57,9 @@ public class Result_ShutdownScriptInvalidShutdownScriptZ: NativeTypeWrapper {
         return Result_ShutdownScriptInvalidShutdownScriptZ(pointer: CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o.danglingClone().cOpaqueStruct!));
     }
 
-    public class func err(e: InvalidShutdownScript) -> Result_ShutdownScriptInvalidShutdownScriptZ {
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public class func err(e: InvalidShutdownScript) -> Result_ShutdownScriptInvalidShutdownScriptZ {
     	
         return Result_ShutdownScriptInvalidShutdownScriptZ(pointer: CResult_ShutdownScriptInvalidShutdownScriptZ_err(e.cOpaqueStruct!));
     }
diff --git a/bindings/LDK/results/Result_StringErrorZ.swift b/bindings/LDK/results/Result_StringErrorZ.swift
@@ -57,7 +57,9 @@ public class Result_StringErrorZ: NativeTypeWrapper {
         return Result_StringErrorZ(pointer: CResult_StringErrorZ_ok(Bindings.new_LDKStr(string: o)));
     }
 
-    public class func err(e: LDKSecp256k1Error) -> Result_StringErrorZ {
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public class func err(e: LDKSecp256k1Error) -> Result_StringErrorZ {
     	
         return Result_StringErrorZ(pointer: CResult_StringErrorZ_err(e));
     }
diff --git a/bindings/LDK/results/Result_TrustedCommitmentTransactionNoneZ.swift b/bindings/LDK/results/Result_TrustedCommitmentTransactionNoneZ.swift
@@ -45,7 +45,9 @@ public class Result_TrustedCommitmentTransactionNoneZ: NativeTypeWrapper {
 				return nil
 			}
 			
-    public class func ok(o: TrustedCommitmentTransaction) -> Result_TrustedCommitmentTransactionNoneZ {
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public class func ok(o: TrustedCommitmentTransaction) -> Result_TrustedCommitmentTransactionNoneZ {
     	
         return Result_TrustedCommitmentTransactionNoneZ(pointer: CResult_TrustedCommitmentTransactionNoneZ_ok(o.cOpaqueStruct!));
     }
diff --git a/bindings/LDK/results/Result_TxCreationKeysErrorZ.swift b/bindings/LDK/results/Result_TxCreationKeysErrorZ.swift
@@ -57,7 +57,9 @@ public class Result_TxCreationKeysErrorZ: NativeTypeWrapper {
         return Result_TxCreationKeysErrorZ(pointer: CResult_TxCreationKeysErrorZ_ok(o.danglingClone().cOpaqueStruct!));
     }
 
-    public class func err(e: LDKSecp256k1Error) -> Result_TxCreationKeysErrorZ {
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public class func err(e: LDKSecp256k1Error) -> Result_TxCreationKeysErrorZ {
     	
         return Result_TxCreationKeysErrorZ(pointer: CResult_TxCreationKeysErrorZ_err(e));
     }
diff --git a/bindings/LDK/structs/ChainParameters.swift b/bindings/LDK/structs/ChainParameters.swift
@@ -7,7 +7,9 @@ public class ChainParameters: NativeTypeWrapper {
 
 
 	/* DEFAULT_CONSTRUCTOR_START */
-    public init(network_arg: LDKNetwork, best_block_arg: BestBlock) {
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public init(network_arg: LDKNetwork, best_block_arg: BestBlock) {
     	Self.instanceCounter += 1
 		self.instanceNumber = Self.instanceCounter
     	
@@ -16,14 +18,18 @@ public class ChainParameters: NativeTypeWrapper {
     }
     /* DEFAULT_CONSTRUCTOR_END */
 
-    public init(pointer: LDKChainParameters){
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public init(pointer: LDKChainParameters){
     	Self.instanceCounter += 1
 		self.instanceNumber = Self.instanceCounter
 		self.cOpaqueStruct = pointer
 		super.init(conflictAvoidingVariableName: 0)
 	}
 
-	public init(pointer: LDKChainParameters, anchor: NativeTypeWrapper){
+	#warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public init(pointer: LDKChainParameters, anchor: NativeTypeWrapper){
 		Self.instanceCounter += 1
 		self.instanceNumber = Self.instanceCounter
 		self.cOpaqueStruct = pointer
diff --git a/bindings/LDK/structs/PeerManager.swift b/bindings/LDK/structs/PeerManager.swift
@@ -7,7 +7,9 @@ public class PeerManager: NativeTypeWrapper {
 
 
 	/* DEFAULT_CONSTRUCTOR_START */
-    public init(message_handler: MessageHandler, our_node_secret: [UInt8], ephemeral_random_data: [UInt8], logger: Logger) {
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public init(message_handler: MessageHandler, our_node_secret: [UInt8], ephemeral_random_data: [UInt8], logger: Logger) {
     	Self.instanceCounter += 1
 		self.instanceNumber = Self.instanceCounter
     	
@@ -18,14 +20,18 @@ PeerManager_new(message_handler.cOpaqueStruct!, Bindings.new_LDKSecretKey(array:
     }
     /* DEFAULT_CONSTRUCTOR_END */
 
-    public init(pointer: LDKPeerManager){
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public init(pointer: LDKPeerManager){
     	Self.instanceCounter += 1
 		self.instanceNumber = Self.instanceCounter
 		self.cOpaqueStruct = pointer
 		super.init(conflictAvoidingVariableName: 0)
 	}
 
-	public init(pointer: LDKPeerManager, anchor: NativeTypeWrapper){
+	#warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public init(pointer: LDKPeerManager, anchor: NativeTypeWrapper){
 		Self.instanceCounter += 1
 		self.instanceNumber = Self.instanceCounter
 		self.cOpaqueStruct = pointer
diff --git a/bindings/LDK/tuples/C2Tuple_BlockHashChannelManagerZ.swift b/bindings/LDK/tuples/C2Tuple_BlockHashChannelManagerZ.swift
@@ -23,7 +23,9 @@ public class C2Tuple_BlockHashChannelManagerZ: NativeTypeWrapper {
 
     /* TUPLE_METHODS_START */
 
-    public class func new(a: [UInt8], b: ChannelManager) -> C2Tuple_BlockHashChannelManagerZ {
+    #warning("This method passes non-cloneable objects by owned value. Here be dragons.")
+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")
+public class func new(a: [UInt8], b: ChannelManager) -> C2Tuple_BlockHashChannelManagerZ {
     	
         return C2Tuple_BlockHashChannelManagerZ(pointer: C2Tuple_BlockHashChannelManagerZ_new(Bindings.new_LDKThirtyTwoBytes(array: a), b.cOpaqueStruct!));
     }
diff --git a/src/conversion_helper.py b/src/conversion_helper.py
@@ -117,6 +117,7 @@ def prepare_swift_to_native_arguments(cls, argument_types, is_trait_callback=Fal
 					pass
 				elif current_argument_details.rust_obj.startswith('LDK') and not current_argument_details.swift_type.startswith('[') and not is_free_method:
 					non_cloneable_argument_indices_passed_by_ownership.append(argument_index)
+					# clone_infix = '.dangle()'
 				if current_argument_details.rust_obj is not None and (
 					'Option' in current_argument_details.rust_obj or 'Tuple' in current_argument_details.rust_obj or 'Result' in current_argument_details.rust_obj) and not current_argument_details.rust_obj.startswith(
 					'['):
diff --git a/src/generators/opaque_struct_generator.py b/src/generators/opaque_struct_generator.py
@@ -31,6 +31,7 @@ def generate_opaque_struct(self, struct_name, struct_details, all_type_details={
 			swift_arguments = []
 			native_arguments = []
 			constructor_argument_prep = ''
+			deprecation_prefix = ''
 
 			constructor_prepared_arguments = ConversionHelper.prepare_swift_to_native_arguments(constructor_details['argument_types'])
 			constructor_swift_arguments = constructor_prepared_arguments["swift_arguments"]
@@ -41,8 +42,14 @@ def generate_opaque_struct(self, struct_name, struct_details, all_type_details={
 
 			if len(constructor_prepared_arguments['non_cloneable_argument_indices_passed_by_ownership']) > 0:
 				cloneability_warning = 'Non-cloneable types passed by ownership. Here be dragons!'
-				print(f'/// {cloneability_warning}: {constructor_native_name}')
+				deprecation_prefix = '#warning("This method passes non-cloneable objects by owned value. Here be dragons.")\n@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")\n'
+				cloneability_types = []
+				for affected_argument_index in constructor_prepared_arguments['non_cloneable_argument_indices_passed_by_ownership']:
+					cloneability_types.append(f'{constructor_details["argument_types"][affected_argument_index].var_name} ({affected_argument_index})')
+				cloneability_type_message = '; '.join(cloneability_types)
+				print(f'(opaque_struct_generator.py#constructor, warned, deprecated) {cloneability_warning}: {constructor_native_name} [{cloneability_type_message}]')
 
+			mutating_output_file_contents = mutating_output_file_contents.replace('public init', f'{deprecation_prefix}public init')
 			mutating_output_file_contents = mutating_output_file_contents.replace('swift_constructor_arguments', ', '.join(constructor_swift_arguments))
 			mutating_output_file_contents = mutating_output_file_contents.replace('OpaqueStructType(native_constructor_arguments)', constructor_native_call_prefix + 'OpaqueStructType(' + ', '.join(
 				constructor_native_arguments) + ')' + constructor_native_call_suffix)
@@ -116,7 +123,7 @@ def generate_opaque_struct(self, struct_name, struct_details, all_type_details={
 					# swift_argument_message = arguments['swift_arguments'][swift_argument_index] + f' ({swift_argument_index})'
 					cloneability_types.append(f'{current_method_details["argument_types"][affected_argument_index].var_name} ({affected_argument_index})')
 				cloneability_type_message = '; '.join(cloneability_types)
-				print(f'/// {cloneability_warning}: {current_native_method_name} [{cloneability_type_message}]')
+				print(f'(opaque_struct_generator.py#method) {cloneability_warning}: {current_native_method_name} [{cloneability_type_message}]')
 
 			current_replacement = current_replacement.replace('return OpaqueStructType_methodName(native_arguments)',
 															  f'return {value_return_wrappers["prefix"]}OpaqueStructType_methodName(native_arguments){value_return_wrappers["suffix"]}')
diff --git a/src/generators/option_generator.py b/src/generators/option_generator.py
@@ -223,11 +223,18 @@ def generate_option(self, struct_name, struct_details, all_type_details={}):
 
 			prepared_arguments = ConversionHelper.prepare_swift_to_native_arguments(current_method_details['argument_types'], False, force_pass_instance, is_free_method)
 			static_infix = 'class ' if prepared_arguments['static_eligible'] else ''
+			deprecation_prefix = ''
 
 			if len(prepared_arguments['non_cloneable_argument_indices_passed_by_ownership']) > 0:
 				cloneability_warning = 'Non-cloneable types passed by ownership. Here be dragons!'
-				print(f'/// {cloneability_warning}: {current_native_method_name}')
-
+				# deprecation_prefix = '#warning("This method passes non-cloneable objects by owned value. Here be dragons.")\n@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")\n'
+				cloneability_types = []
+				for affected_argument_index in prepared_arguments['non_cloneable_argument_indices_passed_by_ownership']:
+					cloneability_types.append(f'{current_method_details["argument_types"][affected_argument_index].var_name} ({affected_argument_index})')
+				cloneability_type_message = '; '.join(cloneability_types)
+				print(f'(option_generator.py) {cloneability_warning}: {current_native_method_name} [{cloneability_type_message}]')
+
+			current_replacement = current_replacement.replace('public func', f'{deprecation_prefix}public func')
 			current_replacement = current_replacement.replace('func methodName(', f'{static_infix}func {current_method_name}(')
 			current_replacement = current_replacement.replace('OptionType_methodName(native_arguments)',
 															  prepared_arguments['native_call_prefix'] + 'OptionType_methodName(' + ', '.join(prepared_arguments['native_arguments']) + ')' +
diff --git a/src/generators/result_generator.py b/src/generators/result_generator.py
@@ -104,6 +104,7 @@ def generate_result(self, struct_name, struct_details, all_type_details={}):
 			current_replacement = method_template
 			is_clone_method = current_method_details['is_clone']
 			is_free_method = current_method_details['is_free']
+			deprecation_prefix = ''
 
 			force_pass_instance = False
 			if len(current_method_details['argument_types']) == 1:
@@ -115,14 +116,20 @@ def generate_result(self, struct_name, struct_details, all_type_details={}):
 
 			if len(prepared_arguments['non_cloneable_argument_indices_passed_by_ownership']) > 0:
 				cloneability_warning = 'Non-cloneable types passed by ownership. Here be dragons!'
-				print(f'/// {cloneability_warning}: {current_native_method_name}')
+				deprecation_prefix = '#warning("This method passes non-cloneable objects by owned value. Here be dragons.")\n@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")\n'
+				cloneability_types = []
+				for affected_argument_index in prepared_arguments['non_cloneable_argument_indices_passed_by_ownership']:
+					cloneability_types.append(f'{current_method_details["argument_types"][affected_argument_index].var_name} ({affected_argument_index})')
+				cloneability_type_message = '; '.join(cloneability_types)
+				print(f'(result_generator.py, warned, deprecated) {cloneability_warning}: {current_native_method_name} [{cloneability_type_message}]')
 
 			current_replacement = current_replacement.replace('return ResultType_methodName(native_arguments)',
 															  f'return {value_return_wrappers["prefix"]}ResultType_methodName(native_arguments){value_return_wrappers["suffix"]}')
 			current_replacement = current_replacement.replace('ResultType_methodName(native_arguments)',
 															  prepared_arguments['native_call_prefix'] + 'ResultType_methodName(' + ', '.join(prepared_arguments['native_arguments']) + ')' +
 															  prepared_arguments['native_call_suffix'])
 			current_replacement = current_replacement.replace('ResultType_methodName(', f'{current_native_method_name}(')
+			current_replacement = current_replacement.replace('public func', f'{deprecation_prefix}public func')
 			current_replacement = current_replacement.replace('func methodName(', f'{static_infix}func {current_method_name}(')
 			current_replacement = current_replacement.replace('swift_arguments', ', '.join(prepared_arguments["swift_arguments"]))
 			current_replacement = current_replacement.replace('native_arguments', ', '.join(prepared_arguments['native_arguments']))
diff --git a/src/generators/trait_generator.py b/src/generators/trait_generator.py
diff --git a/src/generators/tuple_generator.py b/src/generators/tuple_generator.py
diff --git a/src/generators/util_generators/static_method_generator.py b/src/generators/util_generators/static_method_generator.py

Original file line number	Diff line number	Diff line change
`@@ -3938,12 +3938,11 @@ public class Bindings {`
`3938`	`3938`	`}`
`3939`	`3939`
`3940`	`3940`	`}`
`3941`		`-`
`3942`		`-/// Non-cloneable types passed by ownership. Here be dragons!`
	`3941`	`+ #warning("This method passes non-cloneable objects by owned value. Here be dragons.")`
	`3942`	`+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")`
`3943`	`3943`	`public class func swift_C2Tuple_BlockHashChannelManagerZ_read(ser: [UInt8], arg: ChannelManagerReadArgs) -> Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {`
`3944`	`3944`
`3945`		`- print("DANGER! Non-cloneable types passed by ownership. Affected arguments: [arg: ChannelManagerReadArgs (1)]")`
`3946`		`-`
	`3945`	`+`
`3947`	`3946`	`let serWrapper = Bindings.new_LDKu8sliceWrapper(array: ser)`
`3948`	`3947`	`defer {`
`3949`	`3948`	`serWrapper.noOpRetain()`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,9 @@ public class Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ: NativeTypeWrap`
`52`	`52`	`return nil`
`53`	`53`	`}`
`54`	`54`
`55`		`- public class func ok(o: C2Tuple_BlockHashChannelManagerZ) -> Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {`
	`55`	`+ #warning("This method passes non-cloneable objects by owned value. Here be dragons.")`
	`56`	`+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")`
	`57`	`+public class func ok(o: C2Tuple_BlockHashChannelManagerZ) -> Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {`
`56`	`58`
`57`	`59`	`return Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(pointer: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o.cOpaqueStruct!));`
`58`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,9 @@ public class Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ: NativeTypeWrap`
`62`	`62`	`return Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(pointer: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(oWrapper.dangle().cOpaqueStruct!));`
`63`	`63`	`}`
`64`	`64`
`65`		`- public class func err(e: LDKIOError) -> Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {`
	`65`	`+ #warning("This method passes non-cloneable objects by owned value. Here be dragons.")`
	`66`	`+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")`
	`67`	`+public class func err(e: LDKIOError) -> Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {`
`66`	`68`
`67`	`69`	`return Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(pointer: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(e));`
`68`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,9 @@ public class Result_NoneErrorZ: NativeTypeWrapper {`
`50`	`50`	`return Result_NoneErrorZ(pointer: CResult_NoneErrorZ_ok());`
`51`	`51`	`}`
`52`	`52`
`53`		`- public class func err(e: LDKIOError) -> Result_NoneErrorZ {`
	`53`	`+ #warning("This method passes non-cloneable objects by owned value. Here be dragons.")`
	`54`	`+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")`
	`55`	`+public class func err(e: LDKIOError) -> Result_NoneErrorZ {`
`54`	`56`
`55`	`57`	`return Result_NoneErrorZ(pointer: CResult_NoneErrorZ_err(e));`
`56`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,9 @@ public class Result_PayeePubKeyErrorZ: NativeTypeWrapper {`
`57`	`57`	`return Result_PayeePubKeyErrorZ(pointer: CResult_PayeePubKeyErrorZ_ok(o.danglingClone().cOpaqueStruct!));`
`58`	`58`	`}`
`59`	`59`
`60`		`- public class func err(e: LDKSecp256k1Error) -> Result_PayeePubKeyErrorZ {`
	`60`	`+ #warning("This method passes non-cloneable objects by owned value. Here be dragons.")`
	`61`	`+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")`
	`62`	`+public class func err(e: LDKSecp256k1Error) -> Result_PayeePubKeyErrorZ {`
`61`	`63`
`62`	`64`	`return Result_PayeePubKeyErrorZ(pointer: CResult_PayeePubKeyErrorZ_err(e));`
`63`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,9 @@ public class Result_SecretKeyErrorZ: NativeTypeWrapper {`
`57`	`57`	`return Result_SecretKeyErrorZ(pointer: CResult_SecretKeyErrorZ_ok(Bindings.new_LDKSecretKey(array: o)));`
`58`	`58`	`}`
`59`	`59`
`60`		`- public class func err(e: LDKSecp256k1Error) -> Result_SecretKeyErrorZ {`
	`60`	`+ #warning("This method passes non-cloneable objects by owned value. Here be dragons.")`
	`61`	`+@available(*, deprecated, message: "This method passes non-cloneable objects by owned value. Here be dragons.")`
	`62`	`+public class func err(e: LDKSecp256k1Error) -> Result_SecretKeyErrorZ {`
`61`	`63`
`62`	`64`	`return Result_SecretKeyErrorZ(pointer: CResult_SecretKeyErrorZ_err(e));`
`63`	`65`	`}`