fix result names and add manual u8slice support

Author: arik-so

src/generators/opaque_struct_generator.py

@@ -40,7 +40,7 @@ def generate_opaque_struct(self, struct_name, struct_details, all_type_details={
 				if current_argument_details.rust_obj is not None and current_argument_details.rust_obj.startswith(
 					'LDK') and current_argument_details.swift_type.startswith('['):
 					constructor_argument_conversion_method = f'let converted_{argument_name} = Bindings.new_{current_argument_details.rust_obj}(array: {argument_name})'
-					constructor_argument_prep += constructor_argument_conversion_method
+					constructor_argument_prep += '\n\t\t'+constructor_argument_conversion_method
 					passed_argument_name = f'converted_{argument_name}'
 				elif current_argument_details.rust_obj == 'LDK' + current_argument_details.swift_type:
 					passed_argument_name += '.cOpaqueStruct!'
@@ -78,7 +78,8 @@ def generate_opaque_struct(self, struct_name, struct_details, all_type_details={
 		for current_method_details in struct_details.methods:
 			current_native_method_name = current_method_details['name']['native']
 			current_method_name = current_method_details['name']['swift']
-			current_return_type = current_method_details['return_type'].swift_type
+			current_return_type = current_method_details['return_type']
+			current_swift_return_type = current_return_type.swift_type
 			# current_rust_return_type = current_method_details['return_type'].rust_obj
 
 			# if current_rust_return_type in all_type_details and all_type_details[current_rust_return_type].type.name == 'UNITARY_ENUM':
@@ -88,22 +89,35 @@ def generate_opaque_struct(self, struct_name, struct_details, all_type_details={
 			current_replacement = method_template
 			is_clone_method = current_method_details['is_clone']
 
-			if current_method_details['return_type'].rust_obj is not None and current_method_details[
-				'return_type'].rust_obj.startswith('LDK') and current_method_details[
-				'return_type'].swift_type.startswith('['):
-				return_type_wrapper_prefix = f'Bindings.{current_method_details["return_type"].rust_obj}_to_array(byteType: '
+			if current_return_type.rust_obj is not None and current_return_type.rust_obj.startswith('LDK') and current_return_type.swift_type.startswith('['):
+				return_type_wrapper_prefix = f'Bindings.{current_method_details["return_type"].rust_obj}_to_array(nativeType: '
 				return_type_wrapper_suffix = ')'
 				current_replacement = current_replacement.replace(
 					'return OpaqueStructType_methodName(native_arguments)',
 					f'return {return_type_wrapper_prefix}OpaqueStructType_methodName(native_arguments){return_type_wrapper_suffix}')
-			elif current_method_details['return_type'].rust_obj == 'LDK' + current_method_details[
-				'return_type'].swift_type and not is_clone_method:
+			elif current_return_type.rust_obj == 'LDK' + current_return_type.swift_type and not is_clone_method:
 				return_type_wrapper_prefix = f'{current_method_details["return_type"].swift_type}(pointer: '
+				# return_type_wrapper_suffix = '.pointee)'
+				return_type_wrapper_suffix = ')'
+				current_replacement = current_replacement.replace(
+					'return OpaqueStructType_methodName(native_arguments)',
+					f'return {return_type_wrapper_prefix}OpaqueStructType_methodName(native_arguments){return_type_wrapper_suffix}')
+			elif current_return_type.rust_obj == 'LDKC' + current_return_type.swift_type and not is_clone_method:
+				return_type_wrapper_prefix = f'{current_method_details["return_type"].swift_type}(pointer: '
+				# return_type_wrapper_suffix = '.pointee)'
 				return_type_wrapper_suffix = ')'
 				current_replacement = current_replacement.replace(
 					'return OpaqueStructType_methodName(native_arguments)',
 					f'return {return_type_wrapper_prefix}OpaqueStructType_methodName(native_arguments){return_type_wrapper_suffix}')
 
+			if current_return_type.rust_obj is None and current_return_type.swift_type.startswith('['):
+				current_replacement = current_replacement.replace(
+					'OpaqueStructType_methodName(native_arguments)',
+					'OpaqueStructType_methodName(native_arguments).pointee')
+
+			if current_return_type.rust_obj is None and current_return_type.swift_type.startswith('['):
+				current_swift_return_type = current_return_type.swift_raw_type
+
 			current_replacement = current_replacement.replace('func methodName(', f'func {current_method_name}(')
 
 			if is_clone_method:
@@ -151,17 +165,22 @@ def generate_opaque_struct(self, struct_name, struct_details, all_type_details={
 				# native_arguments.append(f'{passed_argument_name}')
 				if current_argument_details.rust_obj == 'LDK' + current_argument_details.swift_type and not current_argument_details.is_ptr:
 					native_arguments.append(f'{passed_argument_name}.cOpaqueStruct!')
+				elif current_argument_details.rust_obj is not None and current_argument_details.rust_obj.startswith(
+					'LDK') and current_argument_details.swift_type.startswith('['):
+					native_arguments.append(f'Bindings.new_{current_argument_details.rust_obj}(array: {passed_argument_name})')
 				else:
 					native_arguments.append(f'{passed_argument_name}')
 
+
+
 			current_replacement = current_replacement.replace('swift_arguments', ', '.join(swift_arguments))
 			if is_clone_method:
 				# add closing parenthesis that could not be added further up in the clone initializer
 				current_replacement = current_replacement.replace('native_arguments', ', '.join(native_arguments) + ')')
 			else:
 				current_replacement = current_replacement.replace('native_arguments', ', '.join(native_arguments))
 			current_replacement = current_replacement.replace('/* NATIVE_CALL_PREP */', native_call_prep)
-			current_replacement = current_replacement.replace('-> Void {', f'-> {current_return_type} {{')
+			current_replacement = current_replacement.replace('-> Void {', f'-> {current_swift_return_type} {{')
 
 			struct_methods += '\n' + current_replacement + '\n'
 

src/generators/result_generator.py

@@ -17,7 +17,7 @@ def generate_result(self, struct_name, struct_details, all_type_details={}):
 		# method_names = ['openChannel', 'closeChannel']
 		# native_method_names = ['ChannelHandler_openChannel', 'ChannelHandler_closeChannel']
 
-		swift_struct_name = struct_name[3:]
+		swift_struct_name = struct_name[4:]
 
 		mutating_output_file_contents = self.template
 
@@ -88,7 +88,7 @@ def generate_result(self, struct_name, struct_details, all_type_details={}):
 			if current_method_details['return_type'].rust_obj is not None and current_method_details[
 				'return_type'].rust_obj.startswith('LDK') and current_method_details[
 				'return_type'].swift_type.startswith('['):
-				return_type_wrapper_prefix = f'Bindings.{current_method_details["return_type"].rust_obj}_to_array(byteType: '
+				return_type_wrapper_prefix = f'Bindings.{current_method_details["return_type"].rust_obj}_to_array(nativeType: '
 				return_type_wrapper_suffix = ')'
 				current_replacement = current_replacement.replace(
 					'return ResultType_methodName(native_arguments)',

src/generators/trait_generator.py

@@ -39,6 +39,12 @@ def generate_trait(self, struct_name, struct_details):
 		for current_lambda in struct_details.lambdas:
 			current_lambda_name = current_lambda['name']
 
+			if not current_lambda['is_lambda']:
+				current_field_details = current_lambda['field_details']
+				current_rust_type = current_field_details.rust_obj
+				instantiation_arguments.append(f'{current_lambda_name}: {current_rust_type}()')
+				continue
+
 			current_native_callback_replacement = native_callback_template
 			current_native_callback_replacement = current_native_callback_replacement.replace('func methodNameCallback(', f'func {current_lambda_name}Callback(')
 			current_native_callback_replacement = current_native_callback_replacement.replace('instance: TraitName', f'instance: {swift_struct_name}')
@@ -51,14 +57,26 @@ def generate_trait(self, struct_name, struct_details):
 
 			# let's specify the correct return type
 			swift_raw_return_type = current_lambda['return_type'].swift_raw_type
+			if current_lambda['return_type'].rust_obj is not None and current_lambda['return_type'].rust_obj.startswith('LDK'):
+				swift_raw_return_type = current_lambda['return_type'].rust_obj
+
 			current_native_callback_replacement = current_native_callback_replacement.replace(') -> Void {', f') -> {swift_raw_return_type} {{')
 
 			# let's get the current native arguments, i. e. the arguments we get from C into the native callback
 			native_arguments = []
 			swift_callback_arguments = []
 			swift_argument_string = ''
 			for current_argument in current_lambda['argument_types']:
-				native_arguments.append(f'{current_argument.var_name}: {current_argument.swift_raw_type}?')
+				passed_raw_type = current_argument.swift_raw_type
+				if current_argument.rust_obj is not None and current_argument.rust_obj.startswith('LDK'):
+					passed_raw_type = current_argument.rust_obj
+				if current_argument.is_const:
+					passed_raw_type = f'UnsafePointer<{passed_raw_type}>'
+					if(current_argument.swift_type.startswith('[')):
+						passed_raw_type += '?' # TODO: figure out when tf it actually becomes nullable!
+				# if current_argument.passed_as_ptr:
+				# 	passed_raw_type += '?'
+				native_arguments.append(f'{current_argument.var_name}: {passed_raw_type}')
 				swift_callback_arguments.append(f'{current_argument.var_name}: {current_argument.var_name}')
 			if len(native_arguments) > 0:
 				# add leading comma
@@ -82,7 +100,7 @@ def generate_trait(self, struct_name, struct_details):
 														f'var cOpaqueStruct: {struct_name}?')
 		trait_file = trait_file.replace('self.cOpaqueStruct = TraitType(',
 														f'self.cOpaqueStruct = {struct_name}(')
-		trait_file = trait_file.replace('native_callback_instantiation_arguments', ', '.join(instantiation_arguments))
+		trait_file = trait_file.replace('native_callback_instantiation_arguments', ',\n\t\t\t'.join(instantiation_arguments))
 		trait_file = native_callback_template_regex.sub(f'\g<1>{native_callbacks}\g<3>', trait_file)
 		trait_file = swift_callback_template_regex.sub(f'\g<1>{swift_callbacks}\g<3>', trait_file)
 

src/generators/tuple_generator.py

@@ -47,7 +47,7 @@ def generate_tuple(self, struct_name, struct_details, all_type_details = {}):
 			current_replacement = method_template
 
 			if current_method_details['return_type'].rust_obj is not None and current_method_details['return_type'].rust_obj.startswith('LDK') and current_method_details['return_type'].swift_type.startswith('['):
-				return_type_wrapper_prefix = f'Bindings.{current_method_details["return_type"].rust_obj}_to_array(byteType: '
+				return_type_wrapper_prefix = f'Bindings.{current_method_details["return_type"].rust_obj}_to_array(nativeType: '
 				return_type_wrapper_suffix = ')'
 				current_replacement = current_replacement.replace('return TupleType_methodName(native_arguments)', f'return {return_type_wrapper_prefix}TupleType_methodName(native_arguments){return_type_wrapper_suffix}')
 			elif current_method_details['return_type'].rust_obj == 'LDK' + current_method_details['return_type'].swift_type:

src/generators/util_generators/byte_array_generator.py

@@ -22,10 +22,10 @@ def generate_byte_array(self, byte_array_type_name, byte_array_type_details):
 		mutating_current_byte_array_methods = mutating_current_byte_array_methods.replace('fieldName:',
 																						  f'{byte_array_field.var_name}:')
 		tupleArguments = 'array[0]'
-		tupleReads = f'byteType.{byte_array_field.var_name}.0'
+		tupleReads = f'nativeType.{byte_array_field.var_name}.0'
 		for i in range(1, array_length):
 			tupleArguments += f', array[{i}]'
-			tupleReads += f', byteType.{byte_array_field.var_name}.{i}'
+			tupleReads += f', nativeType.{byte_array_field.var_name}.{i}'
 		mutating_current_byte_array_methods = mutating_current_byte_array_methods.replace('tupleArguments',
 																						  tupleArguments)
 		mutating_current_byte_array_methods = mutating_current_byte_array_methods.replace('tupleReads',

src/generators/util_generators/vector_generator.py

@@ -30,7 +30,7 @@ def generate_vector(self, vector_name, vector_type_details):
 				dimensions -= 1
 				swift_primitive = deepest_iteratee.name
 			if dimensions > 1:
-				conversion_call = f'let convertedEntry = {shallowmost_iteratee.name}_to_array(vector: currentEntry)'
+				conversion_call = f'let convertedEntry = {shallowmost_iteratee.name}_to_array(nativeType: currentEntry)'
 
 		mutating_current_vector_methods = self.template
 		for dim_delta in range(1, dimensions):

src/lightning_header_parser.py

@@ -170,6 +170,8 @@ def populate_type_details(self):
 					trait_fn_lines = []
 					field_var_lines = []
 
+					ordered_interpreted_lines = []
+
 					for idx, struct_line in enumerate(obj_lines):
 						struct_name_match = struct_name_regex.match(struct_line)
 						if struct_name_match is not None:
@@ -196,9 +198,11 @@ def populate_type_details(self):
 						trait_fn_match = line_indicates_trait_regex.match(struct_line)
 						if trait_fn_match is not None:
 							trait_fn_lines.append(trait_fn_match)
+							ordered_interpreted_lines.append({"type": "lambda", "value": trait_fn_match})
 						field_var_match = line_field_var_regex.match(struct_line)
 						if field_var_match is not None:
 							field_var_lines.append(field_var_match)
+							ordered_interpreted_lines.append({"type": "field", "value": field_var_match})
 						field_lines.append(struct_line)
 
 					assert (struct_name is not None)
@@ -259,7 +263,7 @@ def populate_type_details(self):
 						# TODO: vector type (each one needs to be mapped)
 						self.vec_types.add(struct_name)
 						# vector_type_details = None
-						vector_type_details = TypeDetails() # iterator type
+						vector_type_details = TypeDetails()  # iterator type
 						vector_type_details.type = CTypes.VECTOR
 						vector_type_details.name = struct_name
 
@@ -273,7 +277,7 @@ def populate_type_details(self):
 							vector_type_details.is_primitive = True
 							vector_type_details.primitive_swift_counterpart = self.language_constants.c_type_map[vec_ty]
 						self.type_details[struct_name] = vector_type_details
-						# pass
+					# pass
 					elif is_union_enum:
 						assert (struct_name.endswith("_Tag"))
 						struct_name = struct_name[:-4]
@@ -291,7 +295,7 @@ def populate_type_details(self):
 						pass
 					elif len(trait_fn_lines) > 0:
 						self.trait_structs.add(struct_name)
-						lambdas = self.parse_lambda_details(trait_fn_lines)
+						lambdas = self.parse_lambda_details(ordered_interpreted_lines)
 						current_type_detail.lambdas = lambdas
 					elif struct_name == "LDKTxOut":
 						# TODO: why is this even a special case? It's Swift, we dgaf
@@ -359,28 +363,57 @@ def populate_type_details(self):
 						# self.global_methods.add(method_details)
 						pass
 
-	def parse_lambda_details(self, trait_fn_lines):
+	def parse_lambda_details(self, ordered_interpreted_lines):
+		field_var_convs = []
+		flattened_field_var_convs = []
+
 		lambdas = []
-		for fn_line in trait_fn_lines:
-			ret_ty_info = swift_type_mapper.map_types_to_swift(fn_line.group(2).strip() + " ret", None, False,
-															   self.tuple_types, self.unitary_enums,
-															   self.language_constants)
-			is_const = fn_line.group(4) is not None
-
-			arg_tys = []
-			for idx, arg in enumerate(fn_line.group(5).split(',')):
-				if arg == "":
-					continue
-				arg_conv_info = swift_type_mapper.map_types_to_swift(arg, None, False, self.tuple_types,
-																	 self.unitary_enums,
-																	 self.language_constants)
-				arg_tys.append(arg_conv_info)
-			lambdas.append({
-				'name': fn_line.group(3),
-				'is_constant': is_const,
-				'return_type': ret_ty_info,
-				'argument_types': arg_tys
-			})
+
+		for current_interpreted_line in ordered_interpreted_lines:
+			if current_interpreted_line['type'] == 'field':
+				var_line = current_interpreted_line['value']
+				current_field_type = var_line.group(1)
+				current_field_name = var_line.group(2)
+				if False and current_field_type in self.trait_structs:
+					lambdas.append({
+						'name': current_field_name,
+						'field_details': self.type_details[current_field_type],
+						'is_lambda': False
+					})
+				# flattened_field_var_convs.extend(self.type_details[current_field_type])
+				else:
+					mapped = swift_type_mapper.map_types_to_swift(current_field_type + " " + current_field_name, None, False,
+																  self.tuple_types, self.unitary_enums,
+																  self.language_constants)
+					lambdas.append({
+						'name': current_field_name,
+						'field_details': mapped,
+						'is_lambda': False
+					})
+			elif current_interpreted_line['type'] == 'lambda':
+				fn_line = current_interpreted_line['value']
+				ret_ty_info = swift_type_mapper.map_types_to_swift(fn_line.group(2).strip() + " ret", None, False,
+																   self.tuple_types, self.unitary_enums,
+																   self.language_constants)
+				is_const = fn_line.group(4) is not None
+
+				arg_tys = []
+				for idx, arg in enumerate(fn_line.group(5).split(',')):
+					if arg == "":
+						continue
+					arg_conv_info = swift_type_mapper.map_types_to_swift(arg, None, False, self.tuple_types,
+																		 self.unitary_enums,
+																		 self.language_constants)
+					arg_tys.append(arg_conv_info)
+
+				lambdas.append({
+					'name': fn_line.group(3),
+					'is_lambda': True,
+					'is_constant': is_const,
+					'return_type': ret_ty_info,
+					'argument_types': arg_tys
+				})
+
 		return lambdas
 
 	def parse_function_details(self, line, re_match, ret_arr_len, c_call_string):