From 3004a44ff7ba44e84b45a28139ab15cc1cb2735a Mon Sep 17 00:00:00 2001 From: Nazar Kacharaba Date: Mon, 10 Jul 2023 18:24:21 +0300 Subject: [PATCH 1/2] Fix ref type generation for constructor invocation in dart. Signed-off-by: Nazar Kacharaba --- .../generator/dart/DartNameResolver.kt | 9 +- .../input/FieldConstructors.lime | 17 ++ .../field_constructors_nullable_types.dart | 228 ++++++++++++++++++ 3 files changed, 251 insertions(+), 3 deletions(-) create mode 100644 gluecodium/src/test/resources/smoke/field_constructors/output/dart/lib/src/smoke/field_constructors_nullable_types.dart diff --git a/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartNameResolver.kt b/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartNameResolver.kt index 8b4e563c8f..0e60758fbb 100644 --- a/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartNameResolver.kt +++ b/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartNameResolver.kt @@ -142,7 +142,7 @@ internal class DartNameResolver( else -> resolveName(noFieldsConstructor).let { if (it.isEmpty()) "" else ".$it" } } limeValue.values.joinToString( - prefix = "${resolveName(limeValue.typeRef)}$constructorName(", + prefix = "${resolveTypeRefName(limeValue.typeRef, ignoreNullability = true)}$constructorName(", postfix = ")", separator = ", " ) { resolveValue(it) } @@ -259,7 +259,10 @@ internal class DartNameResolver( return "${resolveFullName(parentElement)}.$ownName" } - private fun resolveTypeRefName(limeTypeRef: LimeTypeRef, ignoreDuplicates: Boolean = false): String { + private fun resolveTypeRefName( + limeTypeRef: LimeTypeRef, ignoreDuplicates: Boolean = false, + ignoreNullability: Boolean = false + ): String { val typeName = resolveName(limeTypeRef.type) val importPath = limeTypeRef.type.actualType.external?.dart?.get(IMPORT_PATH_NAME) val alias = when { @@ -268,7 +271,7 @@ internal class DartNameResolver( duplicateNames.contains(typeName) -> limeTypeRef.type.actualType.path.head.joinToString("_") else -> null } - val suffix = if (limeTypeRef.isNullable) "?" else "" + val suffix = if (limeTypeRef.isNullable && !ignoreNullability) "?" else "" return listOfNotNull(alias, typeName).joinToString(".") + suffix } diff --git a/gluecodium/src/test/resources/smoke/field_constructors/input/FieldConstructors.lime b/gluecodium/src/test/resources/smoke/field_constructors/input/FieldConstructors.lime index cae0f69ee4..3e6e0be4ec 100644 --- a/gluecodium/src/test/resources/smoke/field_constructors/input/FieldConstructors.lime +++ b/gluecodium/src/test/resources/smoke/field_constructors/input/FieldConstructors.lime @@ -131,3 +131,20 @@ struct FieldConstructorsParameterDefaults { @Swift(ParameterDefaults) field constructor(stringField, intField, boolField) } + +@Skip(Java, Swift) +struct FieldConstructorsNullableTypes { + enum FoodType { + VEGETABLES, + FRUITS + } + + struct StructWithParameters { + foodType: FoodType = FoodType.FRUITS + + @Skip(Java, Swift) + field constructor(foodType) + } + + nullableField: StructWithParameters? = {FoodType.FRUITS} +} diff --git a/gluecodium/src/test/resources/smoke/field_constructors/output/dart/lib/src/smoke/field_constructors_nullable_types.dart b/gluecodium/src/test/resources/smoke/field_constructors/output/dart/lib/src/smoke/field_constructors_nullable_types.dart new file mode 100644 index 0000000000..058e072ad8 --- /dev/null +++ b/gluecodium/src/test/resources/smoke/field_constructors/output/dart/lib/src/smoke/field_constructors_nullable_types.dart @@ -0,0 +1,228 @@ +import 'dart:ffi'; +import 'package:library/src/_library_context.dart' as __lib; + +class FieldConstructorsNullableTypes { + FieldConstructorsNullableTypes_StructWithParameters? nullableField; + + FieldConstructorsNullableTypes._(this.nullableField); + FieldConstructorsNullableTypes() + : nullableField = FieldConstructorsNullableTypes_StructWithParameters(FieldConstructorsNullableTypes_FoodType.fruits); +} + +enum FieldConstructorsNullableTypes_FoodType { + vegetables, + fruits +} + +// FieldConstructorsNullableTypes_FoodType "private" section, not exported. + +int smokeFieldconstructorsnullabletypesFoodtypeToFfi(FieldConstructorsNullableTypes_FoodType value) { + switch (value) { + case FieldConstructorsNullableTypes_FoodType.vegetables: + return 0; + case FieldConstructorsNullableTypes_FoodType.fruits: + return 1; + default: + throw StateError("Invalid enum value $value for FieldConstructorsNullableTypes_FoodType enum."); + } +} + +FieldConstructorsNullableTypes_FoodType smokeFieldconstructorsnullabletypesFoodtypeFromFfi(int handle) { + switch (handle) { + case 0: + return FieldConstructorsNullableTypes_FoodType.vegetables; + case 1: + return FieldConstructorsNullableTypes_FoodType.fruits; + default: + throw StateError("Invalid numeric value $handle for FieldConstructorsNullableTypes_FoodType enum."); + } +} + +void smokeFieldconstructorsnullabletypesFoodtypeReleaseFfiHandle(int handle) {} + +final _smokeFieldconstructorsnullabletypesFoodtypeCreateHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Pointer Function(Uint32), + Pointer Function(int) + >('library_smoke_FieldConstructorsNullableTypes_FoodType_create_handle_nullable')); +final _smokeFieldconstructorsnullabletypesFoodtypeReleaseHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Void Function(Pointer), + void Function(Pointer) + >('library_smoke_FieldConstructorsNullableTypes_FoodType_release_handle_nullable')); +final _smokeFieldconstructorsnullabletypesFoodtypeGetValueNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Uint32 Function(Pointer), + int Function(Pointer) + >('library_smoke_FieldConstructorsNullableTypes_FoodType_get_value_nullable')); + +Pointer smokeFieldconstructorsnullabletypesFoodtypeToFfiNullable(FieldConstructorsNullableTypes_FoodType? value) { + if (value == null) return Pointer.fromAddress(0); + final _handle = smokeFieldconstructorsnullabletypesFoodtypeToFfi(value); + final result = _smokeFieldconstructorsnullabletypesFoodtypeCreateHandleNullable(_handle); + smokeFieldconstructorsnullabletypesFoodtypeReleaseFfiHandle(_handle); + return result; +} + +FieldConstructorsNullableTypes_FoodType? smokeFieldconstructorsnullabletypesFoodtypeFromFfiNullable(Pointer handle) { + if (handle.address == 0) return null; + final _handle = _smokeFieldconstructorsnullabletypesFoodtypeGetValueNullable(handle); + final result = smokeFieldconstructorsnullabletypesFoodtypeFromFfi(_handle); + smokeFieldconstructorsnullabletypesFoodtypeReleaseFfiHandle(_handle); + return result; +} + +void smokeFieldconstructorsnullabletypesFoodtypeReleaseFfiHandleNullable(Pointer handle) => + _smokeFieldconstructorsnullabletypesFoodtypeReleaseHandleNullable(handle); + +// End of FieldConstructorsNullableTypes_FoodType "private" section. + +class FieldConstructorsNullableTypes_StructWithParameters { + FieldConstructorsNullableTypes_FoodType foodType; + + FieldConstructorsNullableTypes_StructWithParameters(this.foodType); +} + + +// FieldConstructorsNullableTypes_StructWithParameters "private" section, not exported. + +final _smokeFieldconstructorsnullabletypesStructwithparametersCreateHandle = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Pointer Function(Uint32), + Pointer Function(int) + >('library_smoke_FieldConstructorsNullableTypes_StructWithParameters_create_handle')); +final _smokeFieldconstructorsnullabletypesStructwithparametersReleaseHandle = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Void Function(Pointer), + void Function(Pointer) + >('library_smoke_FieldConstructorsNullableTypes_StructWithParameters_release_handle')); +final _smokeFieldconstructorsnullabletypesStructwithparametersGetFieldfoodType = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Uint32 Function(Pointer), + int Function(Pointer) + >('library_smoke_FieldConstructorsNullableTypes_StructWithParameters_get_field_foodType')); + + + +Pointer smokeFieldconstructorsnullabletypesStructwithparametersToFfi(FieldConstructorsNullableTypes_StructWithParameters value) { + final _foodTypeHandle = smokeFieldconstructorsnullabletypesFoodtypeToFfi(value.foodType); + final _result = _smokeFieldconstructorsnullabletypesStructwithparametersCreateHandle(_foodTypeHandle); + smokeFieldconstructorsnullabletypesFoodtypeReleaseFfiHandle(_foodTypeHandle); + return _result; +} + +FieldConstructorsNullableTypes_StructWithParameters smokeFieldconstructorsnullabletypesStructwithparametersFromFfi(Pointer handle) { + final _foodTypeHandle = _smokeFieldconstructorsnullabletypesStructwithparametersGetFieldfoodType(handle); + try { + return FieldConstructorsNullableTypes_StructWithParameters( + smokeFieldconstructorsnullabletypesFoodtypeFromFfi(_foodTypeHandle) + ); + } finally { + smokeFieldconstructorsnullabletypesFoodtypeReleaseFfiHandle(_foodTypeHandle); + } +} + +void smokeFieldconstructorsnullabletypesStructwithparametersReleaseFfiHandle(Pointer handle) => _smokeFieldconstructorsnullabletypesStructwithparametersReleaseHandle(handle); + +// Nullable FieldConstructorsNullableTypes_StructWithParameters + +final _smokeFieldconstructorsnullabletypesStructwithparametersCreateHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Pointer Function(Pointer), + Pointer Function(Pointer) + >('library_smoke_FieldConstructorsNullableTypes_StructWithParameters_create_handle_nullable')); +final _smokeFieldconstructorsnullabletypesStructwithparametersReleaseHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Void Function(Pointer), + void Function(Pointer) + >('library_smoke_FieldConstructorsNullableTypes_StructWithParameters_release_handle_nullable')); +final _smokeFieldconstructorsnullabletypesStructwithparametersGetValueNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Pointer Function(Pointer), + Pointer Function(Pointer) + >('library_smoke_FieldConstructorsNullableTypes_StructWithParameters_get_value_nullable')); + +Pointer smokeFieldconstructorsnullabletypesStructwithparametersToFfiNullable(FieldConstructorsNullableTypes_StructWithParameters? value) { + if (value == null) return Pointer.fromAddress(0); + final _handle = smokeFieldconstructorsnullabletypesStructwithparametersToFfi(value); + final result = _smokeFieldconstructorsnullabletypesStructwithparametersCreateHandleNullable(_handle); + smokeFieldconstructorsnullabletypesStructwithparametersReleaseFfiHandle(_handle); + return result; +} + +FieldConstructorsNullableTypes_StructWithParameters? smokeFieldconstructorsnullabletypesStructwithparametersFromFfiNullable(Pointer handle) { + if (handle.address == 0) return null; + final _handle = _smokeFieldconstructorsnullabletypesStructwithparametersGetValueNullable(handle); + final result = smokeFieldconstructorsnullabletypesStructwithparametersFromFfi(_handle); + smokeFieldconstructorsnullabletypesStructwithparametersReleaseFfiHandle(_handle); + return result; +} + +void smokeFieldconstructorsnullabletypesStructwithparametersReleaseFfiHandleNullable(Pointer handle) => + _smokeFieldconstructorsnullabletypesStructwithparametersReleaseHandleNullable(handle); + +// End of FieldConstructorsNullableTypes_StructWithParameters "private" section. + +// FieldConstructorsNullableTypes "private" section, not exported. + +final _smokeFieldconstructorsnullabletypesCreateHandle = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Pointer Function(Pointer), + Pointer Function(Pointer) + >('library_smoke_FieldConstructorsNullableTypes_create_handle')); +final _smokeFieldconstructorsnullabletypesReleaseHandle = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Void Function(Pointer), + void Function(Pointer) + >('library_smoke_FieldConstructorsNullableTypes_release_handle')); +final _smokeFieldconstructorsnullabletypesGetFieldnullableField = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Pointer Function(Pointer), + Pointer Function(Pointer) + >('library_smoke_FieldConstructorsNullableTypes_get_field_nullableField')); + + + +Pointer smokeFieldconstructorsnullabletypesToFfi(FieldConstructorsNullableTypes value) { + final _nullableFieldHandle = smokeFieldconstructorsnullabletypesStructwithparametersToFfiNullable(value.nullableField); + final _result = _smokeFieldconstructorsnullabletypesCreateHandle(_nullableFieldHandle); + smokeFieldconstructorsnullabletypesStructwithparametersReleaseFfiHandleNullable(_nullableFieldHandle); + return _result; +} + +FieldConstructorsNullableTypes smokeFieldconstructorsnullabletypesFromFfi(Pointer handle) { + final _nullableFieldHandle = _smokeFieldconstructorsnullabletypesGetFieldnullableField(handle); + try { + return FieldConstructorsNullableTypes._( + smokeFieldconstructorsnullabletypesStructwithparametersFromFfiNullable(_nullableFieldHandle) + ); + } finally { + smokeFieldconstructorsnullabletypesStructwithparametersReleaseFfiHandleNullable(_nullableFieldHandle); + } +} + +void smokeFieldconstructorsnullabletypesReleaseFfiHandle(Pointer handle) => _smokeFieldconstructorsnullabletypesReleaseHandle(handle); + +// Nullable FieldConstructorsNullableTypes + +final _smokeFieldconstructorsnullabletypesCreateHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Pointer Function(Pointer), + Pointer Function(Pointer) + >('library_smoke_FieldConstructorsNullableTypes_create_handle_nullable')); +final _smokeFieldconstructorsnullabletypesReleaseHandleNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Void Function(Pointer), + void Function(Pointer) + >('library_smoke_FieldConstructorsNullableTypes_release_handle_nullable')); +final _smokeFieldconstructorsnullabletypesGetValueNullable = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction< + Pointer Function(Pointer), + Pointer Function(Pointer) + >('library_smoke_FieldConstructorsNullableTypes_get_value_nullable')); + +Pointer smokeFieldconstructorsnullabletypesToFfiNullable(FieldConstructorsNullableTypes? value) { + if (value == null) return Pointer.fromAddress(0); + final _handle = smokeFieldconstructorsnullabletypesToFfi(value); + final result = _smokeFieldconstructorsnullabletypesCreateHandleNullable(_handle); + smokeFieldconstructorsnullabletypesReleaseFfiHandle(_handle); + return result; +} + +FieldConstructorsNullableTypes? smokeFieldconstructorsnullabletypesFromFfiNullable(Pointer handle) { + if (handle.address == 0) return null; + final _handle = _smokeFieldconstructorsnullabletypesGetValueNullable(handle); + final result = smokeFieldconstructorsnullabletypesFromFfi(_handle); + smokeFieldconstructorsnullabletypesReleaseFfiHandle(_handle); + return result; +} + +void smokeFieldconstructorsnullabletypesReleaseFfiHandleNullable(Pointer handle) => + _smokeFieldconstructorsnullabletypesReleaseHandleNullable(handle); + +// End of FieldConstructorsNullableTypes "private" section. \ No newline at end of file From 83a2ec4fc8c60d7f42091b52e72f65d2f0b59ce5 Mon Sep 17 00:00:00 2001 From: Nazar Kacharaba Date: Mon, 10 Jul 2023 22:17:46 +0300 Subject: [PATCH 2/2] Add changelog and fix code formatting. Signed-off-by: Nazar Kacharaba --- CHANGELOG.md | 1 + .../com/here/gluecodium/generator/dart/DartNameResolver.kt | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index bc9b81df0c..c36c9cf525 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,7 @@ ### Bug fixes: * Fixed documentation references to constructors in Java. * Added forward declaration for inner interfaces and classes. + * Fixed Dart code generation for struct initialization. ## 13.6.1 ### Bug fixes: diff --git a/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartNameResolver.kt b/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartNameResolver.kt index 0e60758fbb..c1e490269d 100644 --- a/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartNameResolver.kt +++ b/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartNameResolver.kt @@ -260,7 +260,8 @@ internal class DartNameResolver( } private fun resolveTypeRefName( - limeTypeRef: LimeTypeRef, ignoreDuplicates: Boolean = false, + limeTypeRef: LimeTypeRef, + ignoreDuplicates: Boolean = false, ignoreNullability: Boolean = false ): String { val typeName = resolveName(limeTypeRef.type)