From cb8f441b605ebdd09550e2d23e25313c489d458a Mon Sep 17 00:00:00 2001 From: Daniel Kamkha Date: Thu, 17 Jun 2021 08:46:20 +0200 Subject: [PATCH] Generate type aliases in Dart Added dedicated DartTypeAlias template, as type aliases (typedefs) are now supported in Dart language (since Dart version 2.13). Updated other Dart tempates and resolvers to treat type aliases as a normal type, instead of skipping it through to the target type. Added/updated related smoke and functional tests. Unrelated smoke tests are updated in a separate commit. Resolves: #907 Signed-off-by: Daniel Kamkha --- .github/workflows/functional-tests.yml | 4 +- CHANGELOG.md | 6 +++ functional-tests/functional/dart/main.dart | 4 +- .../functional/dart/pubspec.yaml.in | 2 +- .../dart/test/TypeAliases_test.dart | 53 +++++++++++++++++++ .../generator/dart/DartGenerator.kt | 10 ++-- .../generator/dart/DartImportResolver.kt | 13 +++-- .../generator/dart/DartImportsCollector.kt | 7 ++- .../generator/dart/DartNameResolver.kt | 8 ++- .../templates/dart/DartClass.mustache | 3 ++ .../templates/dart/DartInterface.mustache | 3 ++ .../templates/dart/DartPubspec.mustache | 2 +- .../templates/dart/DartStruct.mustache | 3 ++ .../templates/dart/DartTypeAlias.mustache | 22 ++++++++ .../templates/dart/DartTypes.mustache | 3 ++ .../output/dart/lib/src/smoke/type_defs.dart | 42 ++++++++------- 16 files changed, 143 insertions(+), 42 deletions(-) create mode 100644 functional-tests/functional/dart/test/TypeAliases_test.dart create mode 100644 gluecodium/src/main/resources/templates/dart/DartTypeAlias.mustache diff --git a/.github/workflows/functional-tests.yml b/.github/workflows/functional-tests.yml index 0d386d3b35..cc3558bee4 100644 --- a/.github/workflows/functional-tests.yml +++ b/.github/workflows/functional-tests.yml @@ -244,7 +244,7 @@ jobs: - name: Install Dart SDK run: | DART_RELEASE_CHANNEL=stable - DART_VERSION=2.12.0 + DART_VERSION=2.13.3 wget -nv https://storage.googleapis.com/dart-archive/channels/${DART_RELEASE_CHANNEL}/release/${DART_VERSION}/linux_packages/dart_${DART_VERSION}-1_amd64.deb sudo apt -y install ./dart_${DART_VERSION}-1_amd64.deb - name: Build and run functional tests @@ -364,7 +364,7 @@ jobs: - name: Install Dart SDK run: | DART_RELEASE_CHANNEL=stable - DART_VERSION=2.12.0 + DART_VERSION=2.13.3 wget -nv https://storage.googleapis.com/dart-archive/channels/${DART_RELEASE_CHANNEL}/release/${DART_VERSION}/linux_packages/dart_${DART_VERSION}-1_amd64.deb sudo apt -y install ./dart_${DART_VERSION}-1_amd64.deb - name: Build and run functional tests diff --git a/CHANGELOG.md b/CHANGELOG.md index ed433b6d4d..4536e391b3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,11 @@ # Gluecodium project Release Notes +## Unreleased +### Features: + * Added support for type aliases (typedefs) in Dart +### Breaking changes: + * Generated Dart code now requires minimum Dart version 2.13.0. + ## 10.5.3 Release date: 2022-01-05 ### Bug fixes: diff --git a/functional-tests/functional/dart/main.dart b/functional-tests/functional/dart/main.dart index 38bdd6805d..0ac4f23e4a 100644 --- a/functional-tests/functional/dart/main.dart +++ b/functional-tests/functional/dart/main.dart @@ -67,6 +67,7 @@ import "test/StaticIntMethods_test.dart" as StaticIntMethodsTests; import "test/StaticStringMethods_test.dart" as StaticStringMethodsTests; import "test/StructsWithConstants_test.dart" as StructsWithConstantsTests; import "test/StructsWithMethods_test.dart" as StructsWithMethodsTests; +import "test/TypeAliases_test.dart" as TypeAliasesTests; final _allTests = [ BlobsTests.main, @@ -113,7 +114,8 @@ final _allTests = [ StaticIntMethodsTests.main, StaticStringMethodsTests.main, StructsWithConstantsTests.main, - StructsWithMethodsTests.main + StructsWithMethodsTests.main, + TypeAliasesTests.main ]; String _getLibraryPath(String nativeLibraryName) { diff --git a/functional-tests/functional/dart/pubspec.yaml.in b/functional-tests/functional/dart/pubspec.yaml.in index fc0e3241aa..c110503b17 100644 --- a/functional-tests/functional/dart/pubspec.yaml.in +++ b/functional-tests/functional/dart/pubspec.yaml.in @@ -1,6 +1,6 @@ name: FunctionalDartTests environment: - sdk: '>=2.12.0 <3.0.0' + sdk: '>=2.13.0 <3.0.0' dependencies: test: functional: diff --git a/functional-tests/functional/dart/test/TypeAliases_test.dart b/functional-tests/functional/dart/test/TypeAliases_test.dart new file mode 100644 index 0000000000..35037d22b8 --- /dev/null +++ b/functional-tests/functional/dart/test/TypeAliases_test.dart @@ -0,0 +1,53 @@ +// ------------------------------------------------------------------------------------------------- +// Copyright (C) 2016-2021 HERE Europe B.V. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// SPDX-License-Identifier: Apache-2.0 +// License-Filename: LICENSE +// +// ------------------------------------------------------------------------------------------------- + +import "package:test/test.dart"; +import "package:functional/test.dart"; +import "../test_suite.dart"; + +final _testSuite = TestSuite("Type Aliases"); + +void main() { + _testSuite.test("Type alias to struct", () { + final result = StaticTypedefExampleStructTypedef("nonsense"); + + expect(result is StaticTypedefExampleStruct, isTrue); + expect(result.exampleString, "nonsense"); + }); + _testSuite.test("Type alias used by a function", () { + final result = StaticTypedef.returnIntTypedef(2); + + expect(result is int, isTrue); + expect(result, 3); + }); + _testSuite.test("Type alias points to a type alias", () { + final result = StaticTypedef.returnNestedIntTypedef(4); + + expect(result is int, isTrue); + expect(result, 5); + }); + _testSuite.test("Type alias from type collection", () { + final result = StaticTypedef.returnTypedefPointFromTypeCollection(PointTypedef(1.0, 3.0)); + + expect(result is Point, isTrue); + expect(result.x, 1.0); + expect(result.y, 3.0); + }); +} diff --git a/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartGenerator.kt b/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartGenerator.kt index 76a242f576..8a2faae33d 100644 --- a/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartGenerator.kt +++ b/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartGenerator.kt @@ -164,7 +164,7 @@ internal class DartGenerator : Generator { .sortedBy { ffiNameResolver.resolveName(it) } val generatedFiles = dartFilteredModel.topElements.flatMap { - listOfNotNull( + listOf( generateDart( it, dartResolvers, dartNameResolver, listOf(importsCollector, declarationImportsCollector), exportsCollector, typeRepositoriesCollector, generatorPredicates.predicates, descendantInterfaces @@ -194,15 +194,15 @@ internal class DartGenerator : Generator { typeRepositoriesCollector: MutableList, predicates: Map Boolean>, descendantInterfaces: Map> - ): GeneratedFile? { - val contentTemplateName = selectTemplate(rootElement) ?: return null + ): GeneratedFile { + val contentTemplateName = selectTemplate(rootElement) val packagePath = rootElement.path.head.joinToString(separator = "/") val fileName = dartNameResolver.resolveFileName(rootElement) val filePath = "$packagePath/$fileName" val relativePath = "$SRC_DIR_SUFFIX/$filePath.dart" - val allTypes = LimeTypeHelper.getAllTypes(rootElement).filterNot { it is LimeTypeAlias } + val allTypes = LimeTypeHelper.getAllTypes(rootElement) val nonExternalTypes = allTypes.filter { it.external?.dart == null } val freeConstants = (rootElement as? LimeTypesCollection)?.constants ?: emptyList() val allSymbols = @@ -505,7 +505,7 @@ internal class DartGenerator : Generator { is LimeEnumeration -> "dart/DartEnumeration" is LimeException -> "dart/DartException" is LimeLambda -> "dart/DartLambda" - is LimeTypeAlias -> null + is LimeTypeAlias -> "dart/DartTypeAlias" else -> throw GluecodiumExecutionException( "Unsupported top-level element: " + limeElement::class.java.name diff --git a/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartImportResolver.kt b/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartImportResolver.kt index 9cf877e298..f92d53d40a 100644 --- a/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartImportResolver.kt +++ b/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartImportResolver.kt @@ -54,17 +54,16 @@ internal class DartImportResolver( } private fun resolveTypeImports(limeType: LimeType, skipHelpers: Boolean = false): List { - val actualType = limeType.actualType - when (actualType) { - is LimeBasicType -> return resolveBasicTypeImports(actualType) - is LimeGenericType -> return resolveGenericTypeImports(actualType) + when (limeType) { + is LimeBasicType -> return resolveBasicTypeImports(limeType) + is LimeGenericType -> return resolveGenericTypeImports(limeType) } - val externalImport = resolveExternalImport(actualType, IMPORT_PATH_NAME, useAlias = true) + val externalImport = resolveExternalImport(limeType, IMPORT_PATH_NAME, useAlias = true) return when { - externalImport == null -> listOf(createImport(actualType)) + externalImport == null -> listOf(createImport(limeType)) skipHelpers -> listOf(externalImport) - else -> listOf(createImport(actualType), externalImport) + else -> listOf(createImport(limeType), externalImport) } } diff --git a/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartImportsCollector.kt b/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartImportsCollector.kt index bf39d12cab..71e3a36d32 100644 --- a/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartImportsCollector.kt +++ b/gluecodium/src/main/java/com/here/gluecodium/generator/dart/DartImportsCollector.kt @@ -25,7 +25,12 @@ import com.here.gluecodium.model.lime.LimeClass import com.here.gluecodium.model.lime.LimeContainerWithInheritance internal class DartImportsCollector(importsResolver: ImportsResolver) : - GenericImportsCollector(importsResolver, collectTypeRefImports = true, parentTypeFilter = { true }) { + GenericImportsCollector( + importsResolver, + collectTypeRefImports = true, + parentTypeFilter = { true }, + collectTypeAliasImports = true + ) { override fun collectParentTypeRefs(limeContainer: LimeContainerWithInheritance) = when (limeContainer) { 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 f5867dfdc2..16fc956186 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 @@ -44,7 +44,6 @@ import com.here.gluecodium.model.lime.LimeReturnType import com.here.gluecodium.model.lime.LimeSet import com.here.gluecodium.model.lime.LimeStruct import com.here.gluecodium.model.lime.LimeType -import com.here.gluecodium.model.lime.LimeTypeAlias import com.here.gluecodium.model.lime.LimeTypeRef import com.here.gluecodium.model.lime.LimeTypesCollection import com.here.gluecodium.model.lime.LimeValue @@ -81,7 +80,6 @@ internal class DartNameResolver( is LimeValue -> resolveValue(element) is LimeGenericType -> resolveGenericType(element) is LimeTypeRef -> resolveTypeRefName(element) - is LimeTypeAlias -> resolveName(element.typeRef) is LimeType -> resolveTypeName(element) is LimeNamedElement -> getPlatformName(element) else -> @@ -245,11 +243,11 @@ internal class DartNameResolver( private fun resolveTypeRefName(limeTypeRef: LimeTypeRef, ignoreDuplicates: Boolean = false): String { val typeName = resolveName(limeTypeRef.type) - val importPath = limeTypeRef.type.actualType.external?.dart?.get(IMPORT_PATH_NAME) + val importPath = limeTypeRef.type.external?.dart?.get(IMPORT_PATH_NAME) val alias = when { importPath != null -> computeAlias(importPath) ignoreDuplicates -> null - duplicateNames.contains(typeName) -> limeTypeRef.type.actualType.path.head.joinToString("_") + duplicateNames.contains(typeName) -> limeTypeRef.type.path.head.joinToString("_") else -> null } val suffix = if (limeTypeRef.isNullable) "?" else "" @@ -282,7 +280,7 @@ internal class DartNameResolver( private fun buildDuplicateNames() = limeReferenceMap.values .filterIsInstance() - .filterNot { it is LimeTypesCollection || it is LimeTypeAlias || it is LimeGenericType || it is LimeBasicType } + .filterNot { it is LimeTypesCollection || it is LimeGenericType || it is LimeBasicType } .filter { it.external?.dart == null } .groupBy { resolveTypeName(it) } .filterValues { it.size > 1 } diff --git a/gluecodium/src/main/resources/templates/dart/DartClass.mustache b/gluecodium/src/main/resources/templates/dart/DartClass.mustache index 087362e09c..4d26e33c12 100644 --- a/gluecodium/src/main/resources/templates/dart/DartClass.mustache +++ b/gluecodium/src/main/resources/templates/dart/DartClass.mustache @@ -45,6 +45,9 @@ abstract class {{resolveName}}{{!! {{/ifPredicate}} } +{{#typeAliases}} +{{>dart/DartTypeAlias}} +{{/typeAliases}} {{#enumerations}} {{>dart/DartEnumeration}} {{/enumerations}} diff --git a/gluecodium/src/main/resources/templates/dart/DartInterface.mustache b/gluecodium/src/main/resources/templates/dart/DartInterface.mustache index da5f337980..250fcc787f 100644 --- a/gluecodium/src/main/resources/templates/dart/DartInterface.mustache +++ b/gluecodium/src/main/resources/templates/dart/DartInterface.mustache @@ -61,6 +61,9 @@ abstract class {{resolveName}}{{!! {{/ifPredicate}} } +{{#typeAliases}} +{{>dart/DartTypeAlias}} +{{/typeAliases}} {{#enumerations}} {{>dart/DartEnumeration}} {{/enumerations}} diff --git a/gluecodium/src/main/resources/templates/dart/DartPubspec.mustache b/gluecodium/src/main/resources/templates/dart/DartPubspec.mustache index 9ec1c6b416..0d8ac082d6 100644 --- a/gluecodium/src/main/resources/templates/dart/DartPubspec.mustache +++ b/gluecodium/src/main/resources/templates/dart/DartPubspec.mustache @@ -20,7 +20,7 @@ !}} name: {{libraryName}} environment: - sdk: '>=2.12.0 <3.0.0' + sdk: '>=2.13.0 <3.0.0' dependencies: ffi: intl: diff --git a/gluecodium/src/main/resources/templates/dart/DartStruct.mustache b/gluecodium/src/main/resources/templates/dart/DartStruct.mustache index dfca16bf5b..0edc5136ab 100644 --- a/gluecodium/src/main/resources/templates/dart/DartStruct.mustache +++ b/gluecodium/src/main/resources/templates/dart/DartStruct.mustache @@ -70,6 +70,9 @@ class {{resolveName}}{{#if external.dart.converter}}Internal{{/if}} { } {{/unlessPredicate}} +{{#typeAliases}} +{{>dart/DartTypeAlias}} +{{/typeAliases}} {{#enumerations}} {{>dart/DartEnumeration}} {{/enumerations}} diff --git a/gluecodium/src/main/resources/templates/dart/DartTypeAlias.mustache b/gluecodium/src/main/resources/templates/dart/DartTypeAlias.mustache new file mode 100644 index 0000000000..375c53e632 --- /dev/null +++ b/gluecodium/src/main/resources/templates/dart/DartTypeAlias.mustache @@ -0,0 +1,22 @@ +{{!! + ! + ! Copyright (C) 2016-2021 HERE Europe B.V. + ! + ! Licensed under the Apache License, Version 2.0 (the "License"); + ! you may not use this file except in compliance with the License. + ! You may obtain a copy of the License at + ! + ! http://www.apache.org/licenses/LICENSE-2.0 + ! + ! Unless required by applicable law or agreed to in writing, software + ! distributed under the License is distributed on an "AS IS" BASIS, + ! WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + ! See the License for the specific language governing permissions and + ! limitations under the License. + ! + ! SPDX-License-Identifier: Apache-2.0 + ! License-Filename: LICENSE + ! + !}} +{{>dart/DartDocumentation}}{{>dart/DartAttributes}} +typedef {{resolveName visibility}}{{resolveName}} = {{resolveName typeRef}}; diff --git a/gluecodium/src/main/resources/templates/dart/DartTypes.mustache b/gluecodium/src/main/resources/templates/dart/DartTypes.mustache index bd200ce469..94620a5ff4 100644 --- a/gluecodium/src/main/resources/templates/dart/DartTypes.mustache +++ b/gluecodium/src/main/resources/templates/dart/DartTypes.mustache @@ -18,6 +18,9 @@ ! License-Filename: LICENSE ! !}} +{{#typeAliases}} +{{>dart/DartTypeAlias}} +{{/typeAliases}} {{#enumerations}} {{>dart/DartEnumeration}} {{/enumerations}} diff --git a/gluecodium/src/test/resources/smoke/typedefs/output/dart/lib/src/smoke/type_defs.dart b/gluecodium/src/test/resources/smoke/typedefs/output/dart/lib/src/smoke/type_defs.dart index c5dd34e839..760878b68d 100644 --- a/gluecodium/src/test/resources/smoke/typedefs/output/dart/lib/src/smoke/type_defs.dart +++ b/gluecodium/src/test/resources/smoke/typedefs/output/dart/lib/src/smoke/type_defs.dart @@ -7,21 +7,26 @@ import 'package:library/src/generic_types__conversion.dart'; import 'package:library/src/smoke/type_collection.dart'; import 'package:meta/meta.dart'; abstract class TypeDefs { - - static double methodWithPrimitiveTypeDef(double input) => $prototype.methodWithPrimitiveTypeDef(input); - static List methodWithComplexTypeDef(List input) => $prototype.methodWithComplexTypeDef(input); - static double returnNestedIntTypeDef(double input) => $prototype.returnNestedIntTypeDef(input); - static TypeDefs_TestStruct returnTestStructTypeDef(TypeDefs_TestStruct input) => $prototype.returnTestStructTypeDef(input); - static TypeDefs_TestStruct returnNestedStructTypeDef(TypeDefs_TestStruct input) => $prototype.returnNestedStructTypeDef(input); - static Point returnTypeDefPointFromTypeCollection(Point input) => $prototype.returnTypeDefPointFromTypeCollection(input); - List get primitiveTypeProperty; - set primitiveTypeProperty(List value); + static TypeDefs_PrimitiveTypeDef methodWithPrimitiveTypeDef(TypeDefs_PrimitiveTypeDef input) => $prototype.methodWithPrimitiveTypeDef(input); + static TypeDefs_ComplexTypeDef methodWithComplexTypeDef(TypeDefs_ComplexTypeDef input) => $prototype.methodWithComplexTypeDef(input); + static TypeDefs_NestedIntTypeDef returnNestedIntTypeDef(TypeDefs_NestedIntTypeDef input) => $prototype.returnNestedIntTypeDef(input); + static TypeDefs_TestStructTypeDef returnTestStructTypeDef(TypeDefs_TestStructTypeDef input) => $prototype.returnTestStructTypeDef(input); + static TypeDefs_NestedStructTypeDef returnNestedStructTypeDef(TypeDefs_NestedStructTypeDef input) => $prototype.returnNestedStructTypeDef(input); + static PointTypeDef returnTypeDefPointFromTypeCollection(PointTypeDef input) => $prototype.returnTypeDefPointFromTypeCollection(input); + List get primitiveTypeProperty; + set primitiveTypeProperty(List value); /// @nodoc @visibleForTesting static dynamic $prototype = TypeDefs$Impl(Pointer.fromAddress(0)); } +typedef TypeDefs_NestedIntTypeDef = TypeDefs_PrimitiveTypeDef; +typedef TypeDefs_PrimitiveTypeDef = double; +typedef TypeDefs_StructArray = List; +typedef TypeDefs_ComplexTypeDef = TypeDefs_StructArray; +typedef TypeDefs_TestStructTypeDef = TypeDefs_TestStruct; +typedef TypeDefs_NestedStructTypeDef = TypeDefs_TestStructTypeDef; class TypeDefs_StructHavingAliasFieldDefinedBelow { - double field; + TypeDefs_PrimitiveTypeDef field; TypeDefs_StructHavingAliasFieldDefinedBelow(this.field); } // TypeDefs_StructHavingAliasFieldDefinedBelow "private" section, not exported. @@ -163,8 +168,7 @@ final _smokeTypedefsReleaseHandle = __lib.catchArgumentError(() => __lib.nativeL @visibleForTesting class TypeDefs$Impl extends __lib.NativeBase implements TypeDefs { TypeDefs$Impl(Pointer handle) : super(handle); - - double methodWithPrimitiveTypeDef(double input) { + TypeDefs_PrimitiveTypeDef methodWithPrimitiveTypeDef(TypeDefs_PrimitiveTypeDef input) { final _methodWithPrimitiveTypeDefFfi = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction('library_smoke_TypeDefs_methodWithPrimitiveTypeDef__Double')); final _inputHandle = (input); final __resultHandle = _methodWithPrimitiveTypeDefFfi(__lib.LibraryContext.isolateId, _inputHandle); @@ -173,7 +177,7 @@ class TypeDefs$Impl extends __lib.NativeBase implements TypeDefs { } finally { } } - List methodWithComplexTypeDef(List input) { + TypeDefs_ComplexTypeDef methodWithComplexTypeDef(TypeDefs_ComplexTypeDef input) { final _methodWithComplexTypeDefFfi = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction Function(Int32, Pointer), Pointer Function(int, Pointer)>('library_smoke_TypeDefs_methodWithComplexTypeDef__ListOf_smoke_TypeDefs_TestStruct')); final _inputHandle = foobarListofSmokeTypedefsTeststructToFfi(input); final __resultHandle = _methodWithComplexTypeDefFfi(__lib.LibraryContext.isolateId, _inputHandle); @@ -184,7 +188,7 @@ class TypeDefs$Impl extends __lib.NativeBase implements TypeDefs { foobarListofSmokeTypedefsTeststructReleaseFfiHandle(__resultHandle); } } - double returnNestedIntTypeDef(double input) { + TypeDefs_NestedIntTypeDef returnNestedIntTypeDef(TypeDefs_NestedIntTypeDef input) { final _returnNestedIntTypeDefFfi = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction('library_smoke_TypeDefs_returnNestedIntTypeDef__Double')); final _inputHandle = (input); final __resultHandle = _returnNestedIntTypeDefFfi(__lib.LibraryContext.isolateId, _inputHandle); @@ -193,7 +197,7 @@ class TypeDefs$Impl extends __lib.NativeBase implements TypeDefs { } finally { } } - TypeDefs_TestStruct returnTestStructTypeDef(TypeDefs_TestStruct input) { + TypeDefs_TestStructTypeDef returnTestStructTypeDef(TypeDefs_TestStructTypeDef input) { final _returnTestStructTypeDefFfi = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction Function(Int32, Pointer), Pointer Function(int, Pointer)>('library_smoke_TypeDefs_returnTestStructTypeDef__TestStruct')); final _inputHandle = smokeTypedefsTeststructToFfi(input); final __resultHandle = _returnTestStructTypeDefFfi(__lib.LibraryContext.isolateId, _inputHandle); @@ -204,7 +208,7 @@ class TypeDefs$Impl extends __lib.NativeBase implements TypeDefs { smokeTypedefsTeststructReleaseFfiHandle(__resultHandle); } } - TypeDefs_TestStruct returnNestedStructTypeDef(TypeDefs_TestStruct input) { + TypeDefs_NestedStructTypeDef returnNestedStructTypeDef(TypeDefs_NestedStructTypeDef input) { final _returnNestedStructTypeDefFfi = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction Function(Int32, Pointer), Pointer Function(int, Pointer)>('library_smoke_TypeDefs_returnNestedStructTypeDef__TestStruct')); final _inputHandle = smokeTypedefsTeststructToFfi(input); final __resultHandle = _returnNestedStructTypeDefFfi(__lib.LibraryContext.isolateId, _inputHandle); @@ -215,7 +219,7 @@ class TypeDefs$Impl extends __lib.NativeBase implements TypeDefs { smokeTypedefsTeststructReleaseFfiHandle(__resultHandle); } } - Point returnTypeDefPointFromTypeCollection(Point input) { + PointTypeDef returnTypeDefPointFromTypeCollection(PointTypeDef input) { final _returnTypeDefPointFromTypeCollectionFfi = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction Function(Int32, Pointer), Pointer Function(int, Pointer)>('library_smoke_TypeDefs_returnTypeDefPointFromTypeCollection__Point')); final _inputHandle = smokeTypecollectionPointToFfi(input); final __resultHandle = _returnTypeDefPointFromTypeCollectionFfi(__lib.LibraryContext.isolateId, _inputHandle); @@ -227,7 +231,7 @@ class TypeDefs$Impl extends __lib.NativeBase implements TypeDefs { } } @override - List get primitiveTypeProperty { + List get primitiveTypeProperty { final _getFfi = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction Function(Pointer, Int32), Pointer Function(Pointer, int)>('library_smoke_TypeDefs_primitiveTypeProperty_get')); final _handle = this.handle; final __resultHandle = _getFfi(_handle, __lib.LibraryContext.isolateId); @@ -238,7 +242,7 @@ class TypeDefs$Impl extends __lib.NativeBase implements TypeDefs { } } @override - set primitiveTypeProperty(List value) { + set primitiveTypeProperty(List value) { final _setFfi = __lib.catchArgumentError(() => __lib.nativeLibrary.lookupFunction, Int32, Pointer), void Function(Pointer, int, Pointer)>('library_smoke_TypeDefs_primitiveTypeProperty_set__ListOf_Double')); final _valueHandle = foobarListofDoubleToFfi(value); final _handle = this.handle;