Fixed Issue #465: New tests for Exports added (function typedefs).
diff --git a/LanguageFeatures/nnbd/exports_A01_typedef_t09.dart b/LanguageFeatures/nnbd/exports_A01_typedef_t09.dart
new file mode 100644
index 0000000..ee3a3dc
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_typedef_t09.dart
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if generic typedef with nullable unused type
+ * parameter is exported from opted-in library to legacy library and then back
+ * to the opted in code, it retains its status. Typedef is in the form [typedef
+ * <typeIdentifier> <typeParameters> = <functionType>].
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+typedef expected = void Function();
+
+main() {
+ Expect.equals(expected, g_def );
+ Expect.equals(expected, g_nullable_object_def );
+ Expect.equals(expected, g_nullable_int_def );
+ Expect.equals(expected, g_nullable_function_def);
+ Expect.equals(expected, g_null_def );
+ Expect.equals(expected, g_futureOr_def );
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_typedef_t10.dart b/LanguageFeatures/nnbd/exports_A01_typedef_t10.dart
new file mode 100644
index 0000000..f225a99
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_typedef_t10.dart
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if generic typedef with non-nullable unused type
+ * parameter is exported from opted-in library to legacy library and then back
+ * to the opted in code, it retains its status. Typedef is in the form [typedef
+ * <typeIdentifier> <typeParameters> = <functionType>].
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+typedef expected = void Function();
+
+main() {
+ Expect.equals(expected, g_object_def);
+ Expect.equals(expected, g_int_def);
+ Expect.equals(expected, g_function_def);
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_typedef_t11.dart b/LanguageFeatures/nnbd/exports_A01_typedef_t11.dart
new file mode 100644
index 0000000..50f4c0e
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_typedef_t11.dart
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if generic typedef with [Never] unused type parameter
+ * is exported from opted-in library to legacy library and then back to the
+ * opted in code, it retains its status. Typedef is in the form [typedef
+ * <typeIdentifier> <typeParameters> = <functionType>].
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+typedef expected = void Function();
+
+main() {
+ Expect.equals(expected, g_never_def);
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_typedef_t12.dart b/LanguageFeatures/nnbd/exports_A01_typedef_t12.dart
new file mode 100644
index 0000000..4410255
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_typedef_t12.dart
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if generic function typedef with nullable type
+ * parameter is exported from opted-in library to legacy library and then back
+ * to the opted in code, typedef retains its status. Typedef is in the form
+ * [typedef <typeIdentifier> <typeParameters> = <functionType>]. Check function
+ * with argument.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "dart:async";
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+typedef exp_dynamic <T> = void Function(T);
+typedef exp_nullable_int <T extends int?> = void Function(T);
+typedef exp_nullable_object <T extends Object?> = void Function(T);
+typedef exp_nullable_function<T extends Function?> = void Function(T);
+typedef exp_null <T extends Null> = void Function(T);
+typedef exp_futureOr <T extends FutureOr> = void Function(T);
+
+main() {
+ Expect.equals(exp_nullable_int, g_def_nullable_int_arg );
+ Expect.equals(exp_nullable_object, g_def_nullable_object_arg );
+ Expect.equals(exp_dynamic, g_def_dynamic_arg );
+ Expect.equals(exp_nullable_function, g_def_nullable_function_arg);
+ Expect.equals(exp_null, g_def_null_arg );
+ Expect.equals(exp_futureOr, g_def_futureOr_arg );
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_typedef_t13.dart b/LanguageFeatures/nnbd/exports_A01_typedef_t13.dart
new file mode 100644
index 0000000..0201edb
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_typedef_t13.dart
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if generic function typedef with non-nullable type
+ * parameter is exported from opted-in library to legacy library and then back
+ * to the opted in code, typedef retains its status. Typedef is in the form
+ * [typedef <typeIdentifier> <typeParameters> = <functionType>]. Check function
+ * with argument.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+typedef exp_int <T> = void Function(T);
+typedef exp_object <T extends Object> = void Function(T);
+typedef exp_function<T extends Function> = void Function(T);
+
+main() {
+ Expect.equals(exp_int, g_def_int_arg );
+ Expect.equals(exp_object, g_def_object_arg );
+ Expect.equals(exp_function, g_def_function_arg);
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_typedef_t14.dart b/LanguageFeatures/nnbd/exports_A01_typedef_t14.dart
new file mode 100644
index 0000000..2724ddd
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_typedef_t14.dart
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if generic function typedef [Never] type parameter is
+ * exported from opted-in library to legacy library and then back to the opted
+ * in code, typedef retains its status. Typedef is in the form [typedef
+ * <typeIdentifier> <typeParameters> = <functionType>]. Check function with
+ * argument.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+typedef expected = void Function(Never);
+
+main() {
+ Expect.equals(expected, g_def_never_arg);
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_typedef_t15.dart b/LanguageFeatures/nnbd/exports_A01_typedef_t15.dart
new file mode 100644
index 0000000..c807c55
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_typedef_t15.dart
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if generic function typedef with nullable type
+ * parameter is exported from opted-in library to legacy library and then back
+ * to the opted in code, typedef retains its status. Typedef is in the form
+ * [typedef <typeIdentifier> <typeParameters> = <functionType>]. Check function
+ * with return value.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "dart:async";
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+typedef exp_getDynamic <T> = T Function();
+typedef exp_getNullableInt <T extends int?> = T Function();
+typedef exp_getNullableObject <T extends Object?> = T Function();
+typedef exp_getNullableFunction<T extends Function?> = T Function();
+typedef exp_getNull <T extends Null> = T Function();
+typedef exp_getFutureOr <T extends FutureOr> = T Function();
+
+main() {
+ Expect.equals(exp_getNullableInt, g_def_getNullableInt);
+ Expect.equals(exp_getNullableObject, g_def_getNullableObject);
+ Expect.equals(exp_getDynamic, g_def_getDynamic);
+ Expect.equals(exp_getNullableFunction, g_def_getNullableFunction);
+ Expect.equals(exp_getNull, g_def_getNull);
+ Expect.equals(exp_getFutureOr, g_def_getFutureOr);
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_typedef_t16.dart b/LanguageFeatures/nnbd/exports_A01_typedef_t16.dart
new file mode 100644
index 0000000..59cac31
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_typedef_t16.dart
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if generic function typedef with non-nullable type
+ * parameter is exported from opted-in library to legacy library and then back
+ * to the opted in code, typedef retains its status. Typedef is in the form
+ * [typedef <typeIdentifier> <typeParameters> = <functionType>]. Check function
+ * with return value.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+typedef exp_getInt <T extends int> = T Function();
+typedef exp_getObject <T extends Object> = T Function();
+typedef exp_getFunction<T extends Function> = T Function();
+
+main() {
+ Expect.equals(exp_getInt, g_def_getInt );
+ Expect.equals(exp_getObject, g_def_getObject );
+ Expect.equals(exp_getFunction, g_def_getFunction);
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_typedef_t17.dart b/LanguageFeatures/nnbd/exports_A01_typedef_t17.dart
new file mode 100644
index 0000000..fd72903
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_typedef_t17.dart
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if generic function typedef with [Never] type
+ * parameter is exported from opted-in library to legacy library and then back
+ * to the opted in code, typedef retains its status. Typedef is in the form
+ * [typedef <typeIdentifier> <typeParameters> = <functionType>]. Check function
+ * with return value.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+typedef expected = Never Function();
+
+main() {
+ Expect.equals(expected, g_def_getNever);
+}
diff --git a/LanguageFeatures/nnbd/exports_opted_in_lib.dart b/LanguageFeatures/nnbd/exports_opted_in_lib.dart
index c25b84c..468d8eb 100644
--- a/LanguageFeatures/nnbd/exports_opted_in_lib.dart
+++ b/LanguageFeatures/nnbd/exports_opted_in_lib.dart
@@ -50,17 +50,17 @@
// Generic classes with nullable type parameter:
-class GENERIC_NULLABLE<T> { dynamic getParamType() => T; }
-class GENERIC_NULLABLE_INT<T extends int?> { dynamic getParamType() => T; }
-class GENERIC_NULLABLE_OBJECT<T extends Object?> { dynamic getParamType() => T; }
+class GENERIC_NULLABLE <T> { dynamic getParamType() => T; }
+class GENERIC_NULLABLE_INT <T extends int?> { dynamic getParamType() => T; }
+class GENERIC_NULLABLE_OBJECT <T extends Object?> { dynamic getParamType() => T; }
class GENERIC_NULLABLE_FUNCTION<T extends Function?> { dynamic getParamType() => T; }
-class GENERIC_NULL<T extends Null> { dynamic getParamType() => T; }
-class GENERIC_FUTUREOR<T extends FutureOr> { dynamic getParamType() => T; }
+class GENERIC_NULL <T extends Null> { dynamic getParamType() => T; }
+class GENERIC_FUTUREOR <T extends FutureOr> { dynamic getParamType() => T; }
// Generic classes with non-nullable type parameter:
-class GENERIC_NONNULLABLE_INT<T extends int> { dynamic getParamType() => T; }
-class GENERIC_NONNULLABLE_OBJECT<T extends Object> { dynamic getParamType() => T; }
+class GENERIC_NONNULLABLE_INT <T extends int> { dynamic getParamType() => T; }
+class GENERIC_NONNULLABLE_OBJECT <T extends Object> { dynamic getParamType() => T; }
class GENERIC_NONNULLABLE_FUNCTION<T extends Function> { dynamic getParamType() => T; }
class GENERIC_NEVER<T extends Never> { dynamic getParamType() => T; }
@@ -69,115 +69,158 @@
void testme() {}
-void test_nullable_int_arg(int? i) { Expect.isNull(i); }
-void test_nullable_object_arg(Object? i) { Expect.isNull(i); }
-void test_dynamic_arg(dynamic i) { Expect.isNull(i); }
-void test_nullable_function(Function? f) { Expect.isNull(f); }
-void test_null_arg(Null n) { Expect.isNull(n); }
-void test_futureOr_arg(FutureOr i) { Expect.isNull(i); }
+void test_nullable_int_arg (int? i) { Expect.isNull(i); }
+void test_nullable_object_arg(Object? i) { Expect.isNull(i); }
+void test_dynamic_arg (dynamic i) { Expect.isNull(i); }
+void test_nullable_function (Function? f) { Expect.isNull(f); }
+void test_null_arg (Null n) { Expect.isNull(n); }
+void test_futureOr_arg (FutureOr i) { Expect.isNull(i); }
-void test_int_arg(int i) { Expect.equals(1, i); }
-void test_object_arg(Object o) { Expect.equals(1, o); }
-void test_function_arg(Function f) { Expect.equals(testme, f); }
-void test_futureOrInt_arg(FutureOr<int> i) { Expect.equals(1, i); }
+void test_int_arg (int i) { Expect.equals(1, i); }
+void test_object_arg (Object o) { Expect.equals(1, o); }
+void test_function_arg (Function f) { Expect.equals(testme, f); }
+void test_futureOrInt_arg(FutureOr<int> i) { Expect.equals(1, i); }
void test_never_arg(Never n) {}
void test_required_arg({required int i}) { Expect.equals(1, i); }
-int? getNullableInt() => null;
-Object? getNullableObject() => null;
-dynamic getDynamic() => null;
+int? getNullableInt() => null;
+Object? getNullableObject() => null;
+dynamic getDynamic() => null;
Function? getNullableFunction() => null;
-Null getNull() => null;
-FutureOr getFutureOr() => null;
+Null getNull() => null;
+FutureOr getFutureOr() => null;
-int getInt() => 1;
-Object getObject() => 1;
-Function getFunction() => testme;
+int getInt() => 1;
+Object getObject() => 1;
FutureOr<int> getFutureOrInt() => 1;
+Function getFunction() => testme;
Never getNever() => throw("Should not reach here");
// Generic functions:
-void testGenericDynamic<T>() { Expect.equals(Null, T); }
-void testGenericNullableInt<T extends int?>() { Expect.equals(Null, T); }
+void testGenericDynamic <T> () { Expect.equals(Null, T); }
+void testGenericNullableInt <T extends int?> () { Expect.equals(Null, T); }
void testGenericNullableFunction<T extends Function?>() { Expect.equals(Null, T); }
-void testGenericNullableObject<T extends Object?>() { Expect.equals(Null, T); }
-void testGenericNull<T extends Null>() { Expect.equals(Null, T); }
-void testGenericFutureOr<T extends FutureOr>() { Expect.equals(Null, T); }
+void testGenericNullableObject <T extends Object?> () { Expect.equals(Null, T); }
+void testGenericNull <T extends Null> () { Expect.equals(Null, T); }
+void testGenericFutureOr <T extends FutureOr> () { Expect.equals(Null, T); }
-void testGenericInt<T extends int>() {}
+void testGenericInt <T extends int> () {}
void testGenericFunction<T extends Function>() {}
-void testGenericObject<T extends Object>() {}
+void testGenericObject <T extends Object> () {}
void testGenericNever<T extends Never>() {}
-// Function typedefs:
+// Function typedefs like
+// [typedef <typeIdentifier> <typeParameters> = <functionType>].
typedef def = void Function();
-typedef def_nullable_int_arg = void Function(int? i);
-typedef def_nullable_object_arg = void Function(int? i);
-typedef def_dynamic_arg = void Function(dynamic i);
-typedef def_nullable_function_arg = void Function(Function? f);
-typedef def_null_arg = void Function(Null n);
-typedef def_futureOr_arg = void Function(FutureOr i);
+typedef def_nullable_int_arg = void Function(int? );
+typedef def_nullable_object_arg = void Function(Object? );
+typedef def_dynamic_arg = void Function(dynamic );
+typedef def_nullable_function_arg = void Function(Function?);
+typedef def_null_arg = void Function(Null );
+typedef def_futureOr_arg = void Function(FutureOr );
-typedef def_int_arg = void Function(int i);
-typedef def_object_arg = void Function(Object o);
-typedef def_function_arg = void Function(Function f);
-typedef def_futureOrInt_arg = void Function(FutureOr<int> i);
+typedef def_int_arg = void Function(int );
+typedef def_object_arg = void Function(Object );
+typedef def_function_arg = void Function(Function );
+typedef def_futureOrInt_arg = void Function(FutureOr<int>);
-typedef def_never_arg = void Function(Never n);
+typedef def_never_arg = void Function(Never);
typedef def_required_arg = void Function({required int i});
-typedef def_getNullableInt = int? Function();
-typedef def_getNullableObject = Object? Function();
-typedef def_getDynamic = dynamic Function();
+typedef def_getNullableInt = int? Function();
+typedef def_getNullableObject = Object? Function();
+typedef def_getDynamic = dynamic Function();
typedef def_getNullableFunction = Function? Function();
-typedef def_getNull = Null Function();
-typedef def_getFutureOr = FutureOr Function();
+typedef def_getNull = Null Function();
+typedef def_getFutureOr = FutureOr Function();
-typedef def_getInt = int Function();
-typedef def_getObject = Object Function();
-typedef def_getFunction = Function Function();
+typedef def_getInt = int Function();
+typedef def_getObject = Object Function();
+typedef def_getFunction = Function Function();
typedef def_getFutureOrInt = FutureOr<int> Function();
typedef def_getNever = Never Function();
-// Function typedefs 1:
+// Generic function typedefs like
+// [typedef <typeIdentifier> <typeParameters> = <functionType>].
+
+typedef g_def <T> = void Function();
+typedef g_nullable_int_def <T extends int?> = void Function();
+typedef g_nullable_object_def <T extends Object?> = void Function();
+typedef g_nullable_function_def<T extends Function?> = void Function();
+typedef g_null_def <T extends Null> = void Function();
+typedef g_futureOr_def <T extends FutureOr> = void Function();
+
+typedef g_int_def <T extends int> = void Function();
+typedef g_object_def <T extends Object> = void Function();
+typedef g_function_def<T extends Function> = void Function();
+
+typedef g_never_def<T extends Never> = void Function();
+
+typedef g_def_dynamic_arg <T> = void Function(T);
+typedef g_def_nullable_int_arg <T extends int?> = void Function(T);
+typedef g_def_nullable_object_arg <T extends Object?> = void Function(T);
+typedef g_def_nullable_function_arg<T extends Function?> = void Function(T);
+typedef g_def_null_arg <T extends Null> = void Function(T);
+typedef g_def_futureOr_arg <T extends FutureOr> = void Function(T);
+
+typedef g_def_int_arg <T> = void Function(T);
+typedef g_def_object_arg <T extends Object> = void Function(T);
+typedef g_def_function_arg<T extends Function> = void Function(T);
+
+typedef g_def_never_arg<T extends Never> = void Function(T);
+
+typedef g_def_getDynamic <T> = T Function();
+typedef g_def_getNullableInt <T extends int?> = T Function();
+typedef g_def_getNullableObject <T extends Object?> = T Function();
+typedef g_def_getNullableFunction<T extends Function?> = T Function();
+typedef g_def_getNull <T extends Null> = T Function();
+typedef g_def_getFutureOr <T extends FutureOr> = T Function();
+
+typedef g_def_getInt <T extends int> = T Function();
+typedef g_def_getObject <T extends Object> = T Function();
+typedef g_def_getFunction<T extends Function> = T Function();
+
+typedef g_def_getNever<T extends Never> = T Function();
+
+// Function typedefs like [typedef <type> <identifier> <formalParameterPart>].
typedef void def1();
-typedef void def1_nullable_int_arg (int? i);
-typedef void def1_nullable_object_arg (int? i);
-typedef void def1_dynamic_arg (dynamic i);
+typedef void def1_nullable_int_arg (int? i);
+typedef void def1_nullable_object_arg (Object? o);
+typedef void def1_dynamic_arg (dynamic d);
typedef void def1_nullable_function_arg(Function? f);
-typedef void def1_null_arg (Null n);
-typedef void def1_futureOr_arg (FutureOr i);
+typedef void def1_null_arg (Null n);
+typedef void def1_futureOr_arg (FutureOr x);
-typedef void def1_int_arg (int i);
-typedef void def1_object_arg (Object o);
-typedef void def1_function_arg (Function f);
-typedef void def1_futureOrInt_arg(FutureOr<int> i);
+typedef void def1_int_arg (int i);
+typedef void def1_object_arg (Object o);
+typedef void def1_function_arg (Function f);
+typedef void def1_futureOrInt_arg(FutureOr<int> x);
-typedef void def1_never_arg(Never n);
+typedef void def1_never_arg(Never);
typedef void def1_required_arg({required int i});
-typedef int? def1_getNullableInt();
-typedef Object? def1_getNullableObject();
-typedef dynamic def1_getDynamic();
+typedef int? def1_getNullableInt ();
+typedef Object? def1_getNullableObject ();
+typedef dynamic def1_getDynamic ();
typedef Function? def1_getNullableFunction();
-typedef Null def1_getNull();
-typedef FutureOr def1_getFutureOr();
+typedef Null def1_getNull ();
+typedef FutureOr def1_getFutureOr ();
-typedef int def1_getInt();
-typedef Object def1_getObject();
-typedef Function def1_getFunction();
+typedef int def1_getInt ();
+typedef Object def1_getObject ();
+typedef Function def1_getFunction ();
typedef FutureOr<int> def1_getFutureOrInt();
typedef Never def1_getNever();
