From bd7f7e1dc2b2ab01b6d7534e5a8807dc1708647d 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 | 55 +++++++++++++++++++ .../functional/input/lime/StaticTypedef.lime | 1 + .../generator/dart/DartGenerator.kt | 10 ++-- .../generator/dart/DartImportResolver.kt | 13 ++--- .../generator/dart/DartImportsCollector.kt | 3 +- .../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 ++++++++ .../output/dart/lib/src/smoke/type_defs.dart | 40 ++++++++------ 16 files changed, 139 insertions(+), 40 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 91ca6d10cb..9a33bc343f 100644 --- a/.github/workflows/functional-tests.yml +++ b/.github/workflows/functional-tests.yml @@ -246,7 +246,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 @@ -363,7 +363,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 c9c2a7b06f..253858bb77 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. + ## Unreleased ### Removed: * Support for `types` declaration was removed. diff --git a/functional-tests/functional/dart/main.dart b/functional-tests/functional/dart/main.dart index fcf18b6439..9c6cd6221d 100644 --- a/functional-tests/functional/dart/main.dart +++ b/functional-tests/functional/dart/main.dart @@ -69,6 +69,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 = [ AsyncTests.main, @@ -117,7 +118,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..0bfeefbb1f --- /dev/null +++ b/functional-tests/functional/dart/test/TypeAliases_test.dart @@ -0,0 +1,55 @@ +// ------------------------------------------------------------------------------------------------- +// 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( + TypeCollectionPointTypedef(1.0, 3.0) + ); + + expect(result is TypeCollectionPoint, isTrue); + expect(result.x, 1.0); + expect(result.y, 3.0); + }); +} diff --git a/functional-tests/functional/input/lime/StaticTypedef.lime b/functional-tests/functional/input/lime/StaticTypedef.lime index 36f1c01742..5879aaf0bb 100644 --- a/functional-tests/functional/input/lime/StaticTypedef.lime +++ b/functional-tests/functional/input/lime/StaticTypedef.lime @@ -23,6 +23,7 @@ class StaticTypedef { // Example struct struct ExampleStruct { exampleString: String = "" + field constructor(exampleString) } typealias IntTypedef = Int typealias NestedIntTypedef = IntTypedef 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 8771bd27d3..49b3ca319c 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 @@ -179,7 +179,7 @@ internal class DartGenerator : Generator { injectAsyncHelpers(ffiReferenceMap, asyncHelpers) val generatedFiles = dartFilteredModel.topElements.flatMap { - listOfNotNull( + listOf( generateDart( it, dartResolvers, dartNameResolver, listOf(importsCollector, declarationImportsCollector), exportsCollector, typeRepositoriesCollector, predicatesMap, descendantInterfaces, @@ -214,15 +214,15 @@ internal class DartGenerator : Generator { predicates: Map Boolean>, descendantInterfaces: Map>, asyncHelpers: DartAsyncHelpers.AsyncHelpersGroup? - ): 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 allSymbols = nonExternalTypes.filter { it.visibility.isPublic } if (allSymbols.isNotEmpty()) { @@ -527,7 +527,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 8adf89acf8..d3ea098a8f 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 @@ -56,17 +56,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 a7bc45488b..24254158b5 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 @@ -29,7 +29,8 @@ internal class DartImportsCollector(importsResolver: ImportsResolver importsResolver, collectTypeRefImports = true, collectValueImports = true, - parentTypeFilter = { true } + parentTypeFilter = { true }, + collectTypeAliasImports = true ) { override fun collectParentTypeRefs(limeContainer: LimeContainerWithInheritance) = 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 2f31026f87..34cf7cf92d 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 @@ -48,7 +48,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.LimeTypeHelper import com.here.gluecodium.model.lime.LimeTypeRef import com.here.gluecodium.model.lime.LimeValue @@ -85,7 +84,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 -> @@ -269,11 +267,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 "" @@ -311,7 +309,7 @@ internal class DartNameResolver( private fun buildDuplicateNames() = limeReferenceMap.values .filterIsInstance() - .filterNot { it is LimeTypeAlias || it is LimeGenericType || it is LimeBasicType } + .filterNot { 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 d71e812121..13f790d101 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 8dd7ffe911..7416467f64 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 ce51f3b887..cb8fed1281 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/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 35b092b2a2..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,20 +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 TypeCollection_Point returnTypeDefPointFromTypeCollection(TypeCollection_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. @@ -162,7 +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); @@ -171,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); @@ -182,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); @@ -191,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); @@ -202,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); @@ -213,7 +219,7 @@ class TypeDefs$Impl extends __lib.NativeBase implements TypeDefs { smokeTypedefsTeststructReleaseFfiHandle(__resultHandle); } } - TypeCollection_Point returnTypeDefPointFromTypeCollection(TypeCollection_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); @@ -225,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); @@ -236,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;