Fixed Issue #388: added dynamic tests for non-function type aliases with simple bounds.
diff --git a/LanguageFeatures/Simple-bounds/dynamic/class_typedef_l1_t02.dart b/LanguageFeatures/Simple-bounds/dynamic/class_typedef_l1_t02.dart
index 875f6e8..8739d4c 100644
--- a/LanguageFeatures/Simple-bounds/dynamic/class_typedef_l1_t02.dart
+++ b/LanguageFeatures/Simple-bounds/dynamic/class_typedef_l1_t02.dart
@@ -15,7 +15,6 @@
* every type argument of [G1] has a simple bound.
* @description Checks that simple bounds are correct for the class with
* function parameter (contravariant)
- * @Issue 34689, 35114, 35115
* @author iarkh@unipro.ru
*/
import "../../../Utils/expect.dart";
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_FutureOr_l1_t01.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_FutureOr_l1_t01.dart
new file mode 100644
index 0000000..276c08e
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_FutureOr_l1_t01.dart
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that simple bounds are correct when non-function type
+ * alias parameter is [FutureOr]
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "dart:async";
+import "../../../Utils/expect.dart";
+
+class C<X> {}
+typedef A<X extends FutureOr> = C<X>;
+
+main() {
+ Expect.equals(
+ typeOf<A<FutureOr<dynamic>>>(),
+ typeOf<A>(),
+ );
+}
\ No newline at end of file
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_FutureOr_l1_t02.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_FutureOr_l1_t02.dart
new file mode 100644
index 0000000..863e696
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_FutureOr_l1_t02.dart
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that simple bounds are correct when non-function type
+ * alias parameter is [FutureOr<List>]
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "dart:async";
+import "../../../Utils/expect.dart";
+
+class C<X> {}
+typedef A<X extends FutureOr<List>> = C<X>;
+
+main() {
+ Expect.equals(
+ typeOf<A<FutureOr<List<dynamic>>>>(),
+ typeOf<A>(),
+ );
+}
\ No newline at end of file
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_l1_t01.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_l1_t01.dart
new file mode 100644
index 0000000..995224e
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_l1_t01.dart
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that simple bounds of non-function type alias are correct
+ * for the very simple case: [typedef A<X extends num> = C<X>]
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "../../../Utils/expect.dart";
+
+class C<X> {}
+typedef A<X extends num> = C<X>;
+
+main() {
+ Expect.equals(
+ typeOf<A<num>>(),
+ typeOf<A>(),
+ );
+}
\ No newline at end of file
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_l1_t02.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_l1_t02.dart
new file mode 100644
index 0000000..ca0f2b2
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_l1_t02.dart
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that simple bounds of non-function type alias are correct
+ * for lists and maps parameters: [A<X extends List>], [B<X extends Map>].
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "../../../Utils/expect.dart";
+
+class C<X> {}
+typedef A<X extends List> = C<X>;
+typedef B<X extends Map> = C<X>;
+
+main() {
+ Expect.equals(
+ typeOf<A<List<dynamic>>>(),
+ typeOf<A>(),
+ );
+
+ Expect.equals(
+ typeOf<B<Map<dynamic, dynamic>>>(),
+ typeOf<B>(),
+ );
+
+}
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_l1_t03.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_l1_t03.dart
new file mode 100644
index 0000000..8f42593
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_l1_t03.dart
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that simple bounds of non-function type alias are correct
+ * for [A<X extends List<int>>], [B<X extends Map<int, int>>.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "../../../Utils/expect.dart";
+
+class C<X> {}
+
+typedef A<X extends List<int>> = C<X>;
+typedef B<X extends Map<int, int>> = C<X>;
+
+main() {
+ Expect.equals(
+ typeOf<A<List<int>>>(),
+ typeOf<A>(),
+ );
+
+ Expect.equals(
+ typeOf<B<Map<int, int>>>(),
+ typeOf<B>(),
+ );
+
+}
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_l1_t04.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_l1_t04.dart
new file mode 100644
index 0000000..9366e6a
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_l1_t04.dart
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that simple bounds of non-function type alias are correct
+ * for [A<X extends List<List>>], [B<X extends Map<Map, Map>>]
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "../../../Utils/expect.dart";
+
+class C<X> {}
+
+typedef A<X extends List<List>> = C<X>;
+typedef B<X extends Map<Map, Map>> = C<X>;
+
+
+main() {
+ Expect.equals(
+ typeOf<A<List<List<dynamic>>>>(),
+ typeOf<A>(),
+ );
+ Expect.equals(
+ typeOf<B<Map<Map<dynamic, dynamic>, Map<dynamic, dynamic>>>>(),
+ typeOf<B>(),
+ );
+}
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_l2_t01.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_l2_t01.dart
new file mode 100644
index 0000000..4fcb3cd
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_l2_t01.dart
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that instantiate-to-bounds works as expected for
+ * non-function type alias with two depending typed parameters.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "../../../Utils/expect.dart";
+
+class C<X, Y> {}
+class A<X> {}
+
+typedef B<X extends A, Y extends X> = C<X, Y>;
+
+main() {
+ Expect.equals(
+ typeOf<B<A<dynamic>, A<dynamic>>>(),
+ typeOf<B>(),
+ );
+}
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_l2_t02.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_l2_t02.dart
new file mode 100644
index 0000000..3a748bf
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_l2_t02.dart
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that instantiate-to-bounds works as expected for
+ * non-function type alias with two depending typed parameters.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "../../../Utils/expect.dart";
+
+class C<X, Y> {}
+
+class A<X> {}
+class B<X> {}
+typedef G<X extends A<B>, X1 extends B<X>> = C<X, X1>;
+
+main() {
+ Expect.equals(
+ typeOf<G<A<B<dynamic>>, B<A<B<dynamic>>>>>(),
+ typeOf<G>(),
+ );
+}
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t01.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t01.dart
new file mode 100644
index 0000000..3fc6144
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t01.dart
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that simple bounds are correct for non-function alias
+ * with function parameter (covariant)
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "../../../Utils/expect.dart";
+
+class C<X> {}
+typedef G<X> = X Function();
+typedef A<X extends G> = C<X>;
+
+main() {
+ Expect.equals(
+ typeOf<A<G<dynamic>>>(),
+ typeOf<A>()
+ );
+}
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t02.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t02.dart
new file mode 100644
index 0000000..d7b0e2c
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t02.dart
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that simple bounds are correct for non-function type
+ * alias with function parameter (contravariant)
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "../../../Utils/expect.dart";
+
+class C<X> {}
+
+typedef G<X> = void Function(X);
+typedef A<X extends G> = C<X>;
+
+main() {
+ Expect.equals(
+ typeOf<A<G<dynamic>>>(),
+ typeOf<A>()
+ );
+}
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t03.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t03.dart
new file mode 100644
index 0000000..a6c58c9
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t03.dart
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that simple bounds are correct for non-function type
+ * alias with function parameter (invariant)
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "../../../Utils/expect.dart";
+
+class C<X> {}
+
+typedef G<X> = X Function(X);
+typedef A<X extends G> = C<X>;
+
+main() {
+ Expect.equals(
+ typeOf<A<G<dynamic>>>(),
+ typeOf<A>()
+ );
+}
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t04.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t04.dart
new file mode 100644
index 0000000..169593b
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t04.dart
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that simple bounds are correct for non-function type
+ * alias with function parameter (not used)
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "../../../Utils/expect.dart";
+
+class C<X> {}
+
+typedef G<X> = void Function();
+typedef A<X extends G> = C<X>;
+
+main() {
+ Expect.equals(
+ typeOf<A<G<dynamic>>>(),
+ typeOf<A>()
+ );
+}
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t05.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t05.dart
new file mode 100644
index 0000000..e2c07a6
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t05.dart
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that simple bounds are correct for non-function type
+ * alias with function parameter (covariant)
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "../../../Utils/expect.dart";
+
+class C<X> {}
+
+typedef G<X> = X Function();
+
+typedef A<X extends G<int>> = C<X>;
+
+main() {
+ Expect.equals(
+ typeOf<A<G<int>>>(),
+ typeOf<A>()
+ );
+}
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t06.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t06.dart
new file mode 100644
index 0000000..23342ce
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t06.dart
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that simple bounds are correct for non-function type
+ * alias with function parameter (contravariant)
+ * @author iarkh@unipro.ru
+ */
+import "../../../Utils/expect.dart";
+
+class C<X> {}
+
+typedef G<X> = void Function(X);
+typedef A<X extends G<int>> = C<X>;
+
+main() {
+ Expect.equals(
+ typeOf<A<G<int>>>(),
+ typeOf<A>()
+ );
+}
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t07.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t07.dart
new file mode 100644
index 0000000..d2b7249
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t07.dart
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that simple bounds are correct for non-function type
+ * alias with function parameter (contravariant)
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "../../../Utils/expect.dart";
+
+class C<X> {}
+
+typedef G<X> = void Function(X);
+typedef A<X extends G<int>> = C<X>;
+
+main() {
+ Expect.equals(
+ typeOf<A<G<int>>>(),
+ typeOf<A>()
+ );
+}
diff --git a/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t08.dart b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t08.dart
new file mode 100644
index 0000000..ff1230f
--- /dev/null
+++ b/LanguageFeatures/Simple-bounds/dynamic/typedef1_typedef_l1_t08.dart
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018, 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 Let [G] be a generic class or parameterized type alias with formal
+ * type parameter declarations [F1] .. [Fk] containing formal type parameters
+ * [X1] .. [Xk] and bounds [B1] .. [Bk]. We say that the formal type parameter
+ * [Xj] has a simple bound when one of the following requirements is satisfied:
+ * [Bj] is omitted.
+ * [Bj] is included, but does not contain any of [X1] .. [Xk]. If [Bj] contains
+ * a type [T] on the form qualified (for instance, [C] or [p.D]) which denotes a
+ * generic class or parameterized type alias [G1] (that is, [T] is a raw type),
+ * every type argument of [G1] has a simple bound.
+ * @description Checks that simple bounds are correct for non-function type
+ * alias with function parameter (not used)
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import "../../../Utils/expect.dart";
+
+class C<X> {}
+
+typedef G<X> = void Function();
+typedef A<X extends G<int>> = C<X>;
+
+main() {
+ Expect.equals(
+ typeOf<A<G<int>>>(),
+ typeOf<A>()
+ );
+}
