move array types known a priori to static specification

Author: arik-so

bindings/LDK/results/Result_RecoverableSignatureNoneZ.swift

@@ -45,9 +45,9 @@ public class Result_RecoverableSignatureNoneZ: NativeTypeWrapper {
 				return nil
 			}
 
-    public class func ok(serialized_form: [UInt8]) -> Result_RecoverableSignatureNoneZ {
+    public class func ok(o: [UInt8]) -> Result_RecoverableSignatureNoneZ {
 
-        return Result_RecoverableSignatureNoneZ(pointer: CResult_RecoverableSignatureNoneZ_ok(Bindings.new_LDKRecoverableSignature(array: serialized_form)));
+        return Result_RecoverableSignatureNoneZ(pointer: CResult_RecoverableSignatureNoneZ_ok(Bindings.new_LDKRecoverableSignature(array: o)));
     }
 
     public class func err() -> Result_RecoverableSignatureNoneZ {

src/conversion_helper.py

@@ -4,6 +4,31 @@
 cloneable_types = set()
 detected_cloneable_types = set()
 
+class ArrayAccessorType:
+	def __init__(self, key: str, size: int = -1, length_key = None):
+		self.size: int = size
+		self.key: str = key
+		self.length_key: str = length_key
+
+
+array_accessor_types: dict[str, ArrayAccessorType] = {
+	"LDKThirtyTwoBytes": ArrayAccessorType(size=32, key='data'),
+	"LDKPaymentPreimage": ArrayAccessorType(size=32, key='data'),
+	"LDKPublicKey": ArrayAccessorType(size=33, key='compressed_form'),
+	"LDKSecretKey": ArrayAccessorType(size=32, key='bytes'),
+	"LDKSignature": ArrayAccessorType(size=64, key='compact_form'),
+	"LDKThreeBytes": ArrayAccessorType(size=3, key='data'),
+	"LDKFourBytes": ArrayAccessorType(size=4, key='data'),
+	"LDKTenBytes": ArrayAccessorType(size=10, key='data'),
+	"LDKTwelveBytes": ArrayAccessorType(size=12, key='data'),
+	"LDKSixteenBytes": ArrayAccessorType(size=16, key='data'),
+	"LDKTwentyBytes": ArrayAccessorType(size=20, key='data'),
+	"LDKRecoverableSignature": ArrayAccessorType(size=68, key='serialized_form'),
+	"LDKu8slice": ArrayAccessorType(length_key='datalen', key='data'),
+	"LDKCVec_u8Z": ArrayAccessorType(length_key='datalen', key='data'),
+	"LDKCVec_u5Z": ArrayAccessorType(length_key='datalen', key='data'),
+	"LDKTransaction": ArrayAccessorType(length_key='datalen', key='data'),
+}
 
 class ConversionHelper:
 	trait_structs = set()
@@ -77,7 +102,7 @@ def prepare_swift_to_native_arguments(cls, argument_types, is_trait_callback=Fal
 				pass_instance = True
 				passed_argument_name = 'self'
 				static_eligible = False
-				
+
 				# if caller_is_nullable_inner_type:
 				# 	native_call_prep = f'''
 				# 		if self.cOpaqueStruct!.inner == nil {{
@@ -313,7 +338,7 @@ def prepare_native_to_swift_callback_arguments(cls, argument_types, array_unwrap
 			passed_var_name = received_var_name
 			swift_callback_argument_value = received_var_name
 
-			if published_swift_type == '[UInt8]':
+			if '[UInt8]' in published_swift_type:
 				if inferred_raw_swift_type.startswith('(UInt8'):
 					array_length = current_argument_details.arr_len
 					swift_local_conversion_prefix = f'Bindings.tuple{array_length}_to_array(nativeType: '
@@ -331,8 +356,7 @@ def prepare_native_to_swift_callback_arguments(cls, argument_types, array_unwrap
 					swift_local_conversion_prefix = f'Bindings.LDKu8slice_to_array(nativeType: '
 					swift_local_conversion_suffix = ')'
 					published_swift_type = '[UInt8]'
-			elif published_swift_type == '[[UInt8]]':
-				if received_raw_type == 'LDKCVec_PaymentPreimageZ':
+				elif received_raw_type == 'LDKCVec_PaymentPreimageZ':
 					swift_local_conversion_prefix = f'Bindings.LDKCVec_PaymentPreimageZ_to_array(nativeType: '
 					swift_local_conversion_suffix = ')'
 			elif received_raw_type is not None and received_raw_type.startswith('LDK'):
@@ -437,7 +461,7 @@ def prepare_return_value(cls, return_type, is_clone_method=False, is_trait_insta
 			if (rust_return_type.startswith('LDKCVec_') or rust_return_type == 'LDKTransaction') and is_raw_property_getter:
 				return_suffix = ', deallocate: false)'
 				individual_map_suffix = '.dangle()'
-				
+
 			if TypeParsingRegeces.WRAPPER_TYPE_ARRAY_BRACKET_REGEX.search(return_type_string) and not is_trait_callback:
 				# replace the last [ with [LDK (in case
 				constructor_type = return_type_string.lstrip('[').rstrip(']')
@@ -456,18 +480,18 @@ def prepare_return_value(cls, return_type, is_clone_method=False, is_trait_insta
 
 					map_prefix = f'''.map {{ (cOpaqueStruct) in 
 						cOpaqueStruct''' * (wrapper_depth-1)
-					
+
 					map_suffix = '}' * wrapper_depth
-					
+
 					return_suffix += f'''
 						{map_prefix}
 						.map {{ (cOpaqueStruct) in
 							{constructor_type}(pointer: cOpaqueStruct){individual_map_suffix}
 						{map_suffix}
 					'''
-				
-				
-				
+
+
+
 		elif return_type.swift_raw_type.startswith('(UInt8'):
 			# TODO: get array length
 			array_length = return_type.arr_len

src/swift_type_mapper.py

@@ -1,6 +1,7 @@
 from src.binding_types import TypeInfo
 from src.type_parsing_regeces import TypeParsingRegeces
 from src.conversion_helper import ConversionHelper
+from src.conversion_helper import array_accessor_types
 
 var_is_arr_regex = TypeParsingRegeces.IS_VARIABLE_AN_ARRAY_REGEX
 var_ty_regex = TypeParsingRegeces.VARIABLE_TYPE_REGEX
@@ -37,104 +38,20 @@ def map_types_to_swift(fn_arg, ret_arr_len, java_c_types_none_allowed, tuple_typ
 	# the way that Swift automatically maps C types when divergent from what people use, like const char * not being a String
 	swift_raw_type = None
 
-	if fn_arg.startswith("LDKThirtyTwoBytes"):
-		fn_arg = "uint8_t (*" + fn_arg[18:] + ")[32]"
-		assert var_is_arr_regex.match(fn_arg[8:])
-		rust_obj = "LDKThirtyTwoBytes"
-		swift_raw_type = rust_obj
-		arr_access = "data"
-	elif fn_arg.startswith("LDKPaymentPreimage"): # disable this conversion using x prefix
-		prefix_length = len('LDKPaymentPreimage') + 1
-		fn_arg = "uint8_t (*" + fn_arg[prefix_length:] + ")[32]"
-		assert var_is_arr_regex.match(fn_arg[8:])
-		rust_obj = "LDKPaymentPreimage"
-		swift_raw_type = rust_obj
-		arr_access = "data"
-	elif fn_arg.startswith("LDKPublicKey"):
-		fn_arg = "uint8_t (*" + fn_arg[13:] + ")[33]"
-		assert var_is_arr_regex.match(fn_arg[8:])
-		rust_obj = "LDKPublicKey"
-		swift_raw_type = rust_obj
-		arr_access = "compressed_form"
-	elif fn_arg.startswith("LDKSecretKey"):
-		fn_arg = "uint8_t (*" + fn_arg[13:] + ")[32]"
-		assert var_is_arr_regex.match(fn_arg[8:])
-		rust_obj = "LDKSecretKey"
-		swift_raw_type = rust_obj
-		arr_access = "bytes"
-	elif fn_arg.startswith("LDKSignature"):
-		fn_arg = "uint8_t (*" + fn_arg[13:] + ")[64]"
-		assert var_is_arr_regex.match(fn_arg[8:])
-		rust_obj = "LDKSignature"
-		swift_raw_type = rust_obj
-		arr_access = "compact_form"
-	elif fn_arg.startswith("LDKThreeBytes"):
-		fn_arg = "uint8_t (*" + fn_arg[14:] + ")[3]"
-		assert var_is_arr_regex.match(fn_arg[8:])
-		rust_obj = "LDKThreeBytes"
-		swift_raw_type = rust_obj
-		arr_access = "data"
-	elif fn_arg.startswith("LDKFourBytes"):
-		fn_arg = "uint8_t (*" + fn_arg[13:] + ")[4]"
-		assert var_is_arr_regex.match(fn_arg[8:])
-		rust_obj = "LDKFourBytes"
-		swift_raw_type = rust_obj
-		arr_access = "data"
-	elif fn_arg.startswith("LDKTenBytes"):
-		fn_arg = "uint8_t (*" + fn_arg[12:] + ")[10]"
-		assert var_is_arr_regex.match(fn_arg[8:])
-		rust_obj = "LDKTenBytes"
-		swift_raw_type = rust_obj
-		arr_access = "data"
-	elif fn_arg.startswith("LDKTwelveBytes"):
-		fn_arg = "uint8_t (*" + fn_arg[len('LDKTwelveBytes '):] + ")[12]"
-		assert var_is_arr_regex.match(fn_arg[8:])
-		rust_obj = "LDKTwelveBytes"
-		swift_raw_type = rust_obj
-		arr_access = "data"
-	elif fn_arg.startswith("LDKSixteenBytes"):
-		fn_arg = "uint8_t (*" + fn_arg[16:] + ")[16]"
-		assert var_is_arr_regex.match(fn_arg[8:])
-		rust_obj = "LDKSixteenBytes"
-		swift_raw_type = rust_obj
-		arr_access = "data"
-	elif fn_arg.startswith("LDKTwentyBytes"):
-		fn_arg = "uint8_t (*" + fn_arg[15:] + ")[20]"
-		assert var_is_arr_regex.match(fn_arg[8:])
-		rust_obj = "LDKTwentyBytes"
-		swift_raw_type = rust_obj
-		arr_access = "data"
-	elif fn_arg.startswith("LDKRecoverableSignature"):
-		fn_arg = "uint8_t (*serialized_form)[68]"
-		assert var_is_arr_regex.match(fn_arg[8:])
-		rust_obj = "LDKRecoverableSignature"
-		swift_raw_type = rust_obj
-		arr_access = "serialized_form"
-	elif fn_arg.startswith("LDKu8slice"):
-		fn_arg = "uint8_t (*" + fn_arg[11:] + ")[datalen]"
-		assert var_is_arr_regex.match(fn_arg[8:])
-		rust_obj = "LDKu8slice"
-		arr_access = "data"
-	elif fn_arg.startswith("LDKCVec_u8Z"):
-		fn_arg = "uint8_t (*" + fn_arg[12:] + ")[datalen]"
-		rust_obj = "LDKCVec_u8Z"
-		swift_raw_type = rust_obj
-		assert var_is_arr_regex.match(fn_arg[8:])
-		arr_access = "data"
-	elif fn_arg.startswith("LDKCVec_u5Z"):
-		prefix_length = len('LDKCVec_u5Z') + 1
-		fn_arg = "uint8_t (*" + fn_arg[prefix_length:] + ")[data]"
-		rust_obj = "LDKCVec_u5Z"
-		swift_raw_type = rust_obj
-		assert var_is_arr_regex.match(fn_arg[8:])
-		arr_access = "data"
-	elif fn_arg.startswith("LDKTransaction ") or fn_arg == "LDKTransaction":
-		fn_arg = "uint8_t (*" + fn_arg[15:] + ")[datalen]"
-		rust_obj = "LDKTransaction"
-		swift_raw_type = rust_obj
-		assert var_is_arr_regex.match(fn_arg[8:])
-		arr_access = "data"
-	elif fn_arg.startswith("LDKCVec_"):
+	for type_name, access_details in array_accessor_types.items():
+		if fn_arg.startswith(f'{type_name} ') or fn_arg == type_name: # include space
+			rust_obj = type_name
+			arr_access = access_details.key
+			prefix_length = len(type_name) + 1
+			if access_details.size > 0:
+				fn_arg = "uint8_t (*" + fn_arg[prefix_length:] + f")[{access_details.size}]"
+				assert var_is_arr_regex.match(fn_arg[8:])
+				swift_raw_type = rust_obj
+			elif access_details.size == -1 and access_details.length_key is not None:
+				fn_arg = "uint8_t (*" + fn_arg[prefix_length:] + f")[{access_details.length_key}]"
+				assert var_is_arr_regex.match(fn_arg[8:])
+			break
+	if fn_arg.startswith("LDKCVec_"):
 		is_ptr = False
 		if "*" in fn_arg:
 			fn_arg = fn_arg.replace("*", "")