fix reference prefix for mutable pointer-based constructors

arik-so · arik-so · commit 55f3d30074d8 · 2021-05-04T03:28:23.000-07:00
diff --git a/src/generators/opaque_struct_generator.py b/src/generators/opaque_struct_generator.py
@@ -42,6 +42,21 @@ def generate_opaque_struct(self, struct_name, struct_details, all_type_details={
 					constructor_argument_conversion_method = f'let converted_{argument_name} = Bindings.new_{current_argument_details.rust_obj}(array: {argument_name})'
 					constructor_argument_prep += '\n\t\t'+constructor_argument_conversion_method
 					passed_argument_name = f'converted_{argument_name}'
+				elif current_argument_details.is_ptr:
+					passed_argument_name = argument_name + 'Pointer'
+					requires_mutability = not current_argument_details.is_const
+					mutability_infix = ''
+					reference_prefix = ''
+					if requires_mutability:
+						# argument_name = '&' + argument_name
+						reference_prefix = '&'
+						mutability_infix = 'Mutable'
+					current_prep = f'''
+							\n\t	let {passed_argument_name} = withUnsafe{mutability_infix}Pointer(to: {reference_prefix}{argument_name}.cOpaqueStruct!) {{ (pointer: Unsafe{mutability_infix}Pointer<{current_argument_details.rust_obj}>) in
+								\n\t\t	pointer
+							\n\t	}}
+						'''
+					constructor_argument_prep += current_prep
 				elif current_argument_details.rust_obj == 'LDK' + current_argument_details.swift_type:
 					passed_argument_name += '.cOpaqueStruct!'
 
@@ -97,8 +112,9 @@ def generate_opaque_struct(self, struct_name, struct_details, all_type_details={
 					f'return {return_type_wrapper_prefix}OpaqueStructType_methodName(native_arguments){return_type_wrapper_suffix}')
 			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 = ')'
+				if current_return_type.is_const:
+					return_type_wrapper_suffix = '.pointee)'
 				current_replacement = current_replacement.replace(
 					'return OpaqueStructType_methodName(native_arguments)',
 					f'return {return_type_wrapper_prefix}OpaqueStructType_methodName(native_arguments){return_type_wrapper_suffix}')
@@ -168,6 +184,8 @@ def generate_opaque_struct(self, struct_name, struct_details, all_type_details={
 				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})')
+				elif current_argument_details.rust_obj is None and current_argument_details.arr_len is not None and current_argument_details.arr_len.isnumeric():
+					native_arguments.append(f'Bindings.array_to_tuple{current_argument_details.arr_len}(array: {passed_argument_name})')
 				else:
 					native_arguments.append(f'{passed_argument_name}')
 
diff --git a/src/generators/option_generator.py b/src/generators/option_generator.py
@@ -0,0 +1,225 @@
+import re
+import os
+
+from config import Config
+
+
+class OptionGenerator:
+
+	def __init__(self) -> None:
+		super().__init__()
+		template_path = f'{os.path.dirname(__file__)}/../../templates/OptionTemplate.swift'
+		with open(template_path, 'r') as template_handle:
+			template = template_handle.read()
+			self.template = template
+
+	def generate_option(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:]
+		if swift_struct_name.startswith('COption'):
+			swift_struct_name = struct_name[4:]
+
+		mutating_output_file_contents = self.template
+
+		# CONSTRUCTOR START
+		if struct_details.constructor_method is not None:
+			# fill constructor details
+			constructor_details = struct_details.constructor_method
+			constructor_native_name = constructor_details['name']['native']
+			swift_arguments = []
+			native_arguments = []
+			constructor_argument_prep = ''
+			for current_argument_details in constructor_details['argument_types']:
+				argument_name = current_argument_details.var_name
+				passed_argument_name = argument_name
+				constructor_argument_conversion_method = None
+
+				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
+					passed_argument_name = f'converted_{argument_name}'
+				elif current_argument_details.rust_obj == 'LDK' + current_argument_details.swift_type:
+					passed_argument_name += '.cOpaqueStruct!'
+
+				swift_arguments.append(f'{argument_name}: {current_argument_details.swift_type}')
+				native_arguments.append(f'{passed_argument_name}')
+
+			mutating_output_file_contents = mutating_output_file_contents.replace('swift_constructor_arguments',
+																				  ', '.join(swift_arguments))
+			mutating_output_file_contents = mutating_output_file_contents.replace('/* NATIVE_CONSTRUCTOR_PREP */',
+																				  constructor_argument_prep)
+			mutating_output_file_contents = mutating_output_file_contents.replace('native_constructor_arguments',
+																				  ', '.join(native_arguments))
+			mutating_output_file_contents = mutating_output_file_contents.replace(
+				'self.cOpaqueStruct = OptionType(',
+				f'self.cOpaqueStruct = {constructor_native_name}(')
+		else:
+			# remove the default constructor template
+			constructor_template_regex = re.compile(
+				"(\/\* DEFAULT_CONSTRUCTOR_START \*\/\n)(.*)(\n[\t ]*\/\* DEFAULT_CONSTRUCTOR_END \*\/)",
+				flags=re.MULTILINE | re.DOTALL)
+			mutating_output_file_contents = constructor_template_regex.sub('', mutating_output_file_contents)
+
+		# REGULAR METHODS START
+
+		method_template_regex = re.compile(
+			"(\/\* OPTION_METHODS_START \*\/\n)(.*)(\n[\t ]*\/\* OPTION_METHODS_END \*\/)",
+			flags=re.MULTILINE | re.DOTALL)
+		method_template = method_template_regex.search(mutating_output_file_contents).group(2)
+
+		method_prefix = swift_struct_name + '_'
+		struct_methods = ''
+
+		# fill templates
+		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_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':
+			# 	current_return_type = current_rust_return_type
+			current_method_name = current_native_method_name[len(method_prefix):]
+
+			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(nativeType: '
+				return_type_wrapper_suffix = ')'
+				current_replacement = current_replacement.replace(
+					'return OptionType_methodName(native_arguments)',
+					f'return {return_type_wrapper_prefix}OptionType_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:
+				return_type_wrapper_prefix = f'{current_method_details["return_type"].swift_type}(pointer: '
+				return_type_wrapper_suffix = ')'
+				current_replacement = current_replacement.replace(
+					'return OptionType_methodName(native_arguments)',
+					f'return {return_type_wrapper_prefix}OptionType_methodName(native_arguments){return_type_wrapper_suffix}')
+
+			current_replacement = current_replacement.replace('func methodName(', f'func {current_method_name}(')
+
+			if is_clone_method:
+				current_replacement = current_replacement.replace('OptionType_methodName(',
+																  f'{swift_struct_name}(pointer: {current_native_method_name}(')
+			else:
+				current_replacement = current_replacement.replace('OptionType_methodName(',
+																  f'{current_native_method_name}(')
+			# replace arguments
+			swift_arguments = []
+			native_arguments = []
+			native_call_prep = ''
+			for current_argument_details in current_method_details['argument_types']:
+				pass_instance = False
+				argument_name = current_argument_details.var_name
+				passed_argument_name = argument_name
+				if argument_name == 'this_ptr':
+					pass_instance = True
+
+				if current_argument_details.is_ptr:
+					passed_argument_name = argument_name + 'Pointer'
+					requires_mutability = not current_argument_details.is_const
+
+					mutability_infix = ''
+
+					if pass_instance:
+						argument_name = 'self'
+					if requires_mutability:
+						argument_name = '&' + argument_name
+						mutability_infix = 'Mutable'
+					# let managerPointer = withUnsafePointer(to: self.cChannelManager!) { (pointer: UnsafePointer<LDKChannelManager>) in
+					# 	pointer
+					# }
+					# the \n\t will add a bunch of extra lines, but this file will be easier to read
+					current_prep = f'''
+						\n\t	let {passed_argument_name} = withUnsafe{mutability_infix}Pointer(to: {argument_name}.cOpaqueStruct!) {{ (pointer: Unsafe{mutability_infix}Pointer<{current_argument_details.rust_obj}>) in
+							\n\t\t	pointer
+						\n\t	}}
+					'''
+					native_call_prep += current_prep
+
+				if not pass_instance:
+					swift_arguments.append(f'{argument_name}: {current_argument_details.swift_type}')
+
+				# 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!')
+				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} {{')
+
+			struct_methods += '\n' + current_replacement + '\n'
+
+		# DESTRUCTOR START
+		if struct_details.free_method is not None:
+			# fill constructor details
+			free_method_details = struct_details.free_method
+			free_native_name = free_method_details['name']['native']
+			native_call_prep = ''
+			native_arguments = []
+			for current_argument_details in free_method_details['argument_types']:
+				pass_instance = False
+				argument_name = current_argument_details.var_name
+				passed_argument_name = argument_name
+				if argument_name.startswith('this_'):
+					pass_instance = True
+
+				if current_argument_details.is_ptr:
+					passed_argument_name = argument_name + 'Pointer'
+					requires_mutability = not current_argument_details.is_const
+
+					mutability_infix = ''
+
+					if pass_instance:
+						argument_name = 'self'
+					if requires_mutability:
+						argument_name = '&' + argument_name
+						mutability_infix = 'Mutable'
+
+					current_prep = f'''
+							\n\t	let {passed_argument_name} = withUnsafe{mutability_infix}Pointer(to: {argument_name}.cOpaqueStruct!) {{ (pointer: Unsafe{mutability_infix}Pointer<{current_argument_details.rust_obj}>) in
+								\n\t\t	pointer
+							\n\t	}}
+						'''
+					native_call_prep += current_prep
+				elif pass_instance:
+					passed_argument_name = 'self.cOpaqueStruct!'
+				native_arguments.append(f'{passed_argument_name}')
+
+			struct_methods += f'''
+				\n\tdeinit {{
+					{native_call_prep}
+					\n\t	{free_native_name}({', '.join(native_arguments)})
+				\n\t}}
+			'''
+
+		mutating_output_file_contents = mutating_output_file_contents.replace('class OptionName {',
+																			  f'class {swift_struct_name} {{')
+		mutating_output_file_contents = mutating_output_file_contents.replace('init(pointer: OptionType',
+																			  f'init(pointer: {struct_name}')
+		mutating_output_file_contents = mutating_output_file_contents.replace('var cOpaqueStruct: OptionType?',
+																			  f'var cOpaqueStruct: {struct_name}?')
+		mutating_output_file_contents = method_template_regex.sub(f'\g<1>{struct_methods}\g<3>',
+																  mutating_output_file_contents)
+
+		# store the output
+		output_path = f'{Config.OUTPUT_DIRECTORY_PATH}/options/{swift_struct_name}.swift'
+		output_directory = os.path.dirname(output_path)
+		if not os.path.exists(output_directory):
+			os.makedirs(output_directory)
+		with open(output_path, "w") as f:
+			f.write(mutating_output_file_contents)
diff --git a/src/generators/trait_generator.py b/src/generators/trait_generator.py
@@ -59,6 +59,8 @@ def generate_trait(self, struct_name, struct_details):
 			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
+			elif current_lambda['return_type'].pass_by_ref and current_lambda_name == 'clone':
+				swift_raw_return_type = 'UnsafeMutableRawPointer'
 
 			current_native_callback_replacement = current_native_callback_replacement.replace(') -> Void {', f') -> {swift_raw_return_type} {{')
 
diff --git a/src/generators/util_generators/byte_array_generator.py b/src/generators/util_generators/byte_array_generator.py
@@ -11,6 +11,7 @@ def __init__(self) -> None:
 			"(\/\* BYTE_ARRAY_METHODS_START \*\/\n)(.*)(\n[\t ]*\/\* BYTE_ARRAY_METHODS_END \*\/)",
 			flags=re.MULTILINE | re.DOTALL)
 		self.loadTemplate()
+		self.raw_tuple_generators = {}
 
 	def generate_byte_array(self, byte_array_type_name, byte_array_type_details):
 		assert len(byte_array_type_details.fields) == 1
@@ -23,13 +24,31 @@ def generate_byte_array(self, byte_array_type_name, byte_array_type_details):
 																						  f'{byte_array_field.var_name}:')
 		tupleArguments = 'array[0]'
 		tupleReads = f'nativeType.{byte_array_field.var_name}.0'
+		rawTupleReads = f'nativeType.0'
 		for i in range(1, array_length):
 			tupleArguments += f', array[{i}]'
 			tupleReads += f', nativeType.{byte_array_field.var_name}.{i}'
+			rawTupleReads += f', nativeType.{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',
 																						  tupleReads)
 		self.filled_template += "\n" + mutating_current_byte_array_methods + "\n"
 
+		if not array_length in self.raw_tuple_generators:
+			self.raw_tuple_generators[array_length] = True
+			current_generator = f"""
+			static func array_to_tuple{array_length}(array: [UInt8]) -> {byte_array_field.swift_raw_type} {{
+        		return ({tupleArguments})
+			}}
+
+    		static func tuple{array_length}_to_array(nativeType: {byte_array_field.swift_raw_type}) -> [UInt8] {{
+				let array = [{rawTupleReads}]
+				return array
+			}}
+			"""
+
+			self.filled_template += current_generator + "\n"
+
+
 
diff --git a/src/generators/util_generators/vector_generator.py b/src/generators/util_generators/vector_generator.py
@@ -42,9 +42,10 @@ def generate_vector(self, vector_name, vector_type_details):
 		else:
 			mutating_current_vector_methods = mutating_current_vector_methods.replace('(convertedEntry)', '(currentEntry)')
 
-		if not is_primitive:
+		if not is_primitive and dimensions > 2 or is_primitive and dimensions > 3:
 			mutating_current_vector_methods = mutating_current_vector_methods.replace('/* SWIFT_TO_RUST_START */', '/* SWIFT_TO_RUST_START ')
 			mutating_current_vector_methods = mutating_current_vector_methods.replace('/* SWIFT_TO_RUST_END */', 'SWIFT_TO_RUST_END */')
+			# pass
 
 		mutating_current_vector_methods = mutating_current_vector_methods.replace('SwiftPrimitive',
 																				  swift_primitive)
diff --git a/src/lightning_header_parser.py b/src/lightning_header_parser.py
@@ -104,6 +104,7 @@ def populate_type_details(self):
 
 		self.trait_structs = set()
 		self.result_types = set()
+		self.option_types = set()
 		self.vec_types = set()
 		self.byte_arrays = set()
 
@@ -286,12 +287,10 @@ def populate_type_details(self):
 						enum_var_name = struct_name.split("_")
 						union_enum_items[enum_var_name[0]][enum_var_name[1]] = field_lines
 					elif struct_name in union_enum_items:
-						# TODO: complex enum
-						pass
+						self.option_types.add(struct_name)
 					elif is_unitary_enum:
 						self.type_details[struct_name].type = CTypes.UNITARY_ENUM
 						self.unitary_enums.add(struct_name)
-						# todo: unitary enums are to be used as is
 						pass
 					elif len(trait_fn_lines) > 0:
 						self.trait_structs.add(struct_name)
diff --git a/src/sdk_generator.py b/src/sdk_generator.py
@@ -2,6 +2,7 @@
 from generators.opaque_struct_generator import OpaqueStructGenerator
 from generators.tuple_generator import TupleGenerator
 from generators.result_generator import ResultGenerator
+from generators.option_generator import OptionGenerator
 from generators.trait_generator import TraitGenerator
 from generators.util_generators.vector_generator import VectorGenerator
 from generators.util_generators.byte_array_generator import ByteArrayGenerator
@@ -59,6 +60,15 @@ def generate_result_wrappers(parser: LightningHeaderParser):
 		result_generator.generate_result(current_result, current_result_details, all_type_details=parser.type_details)
 
 
+def generate_option_wrappers(parser: LightningHeaderParser):
+	option_generator = OptionGenerator()
+
+	options = parser.option_types
+	for current_option in options:
+		current_option_details = parser.type_details[current_option]
+		option_generator.generate_option(current_option, current_option_details, all_type_details=parser.type_details)
+
+
 def generate_trait_placeholders(parser: LightningHeaderParser):
 	trait_generator = TraitGenerator()
 
@@ -74,6 +84,7 @@ def generate_sdk():
 	generate_opaque_struct_wrappers(parser)
 	generate_tuple_wrappers(parser)
 	generate_result_wrappers(parser)
+	generate_option_wrappers(parser)
 	generate_trait_placeholders(parser)
 
 
diff --git a/templates/BindingsTemplate.swift b/templates/BindingsTemplate.swift
diff --git a/templates/OptionTemplate.swift b/templates/OptionTemplate.swift
