diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_FutureOr_l1_t01.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_FutureOr_l1_t01.dart
index 333b091..2f774d4 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_FutureOr_l1_t01.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_FutureOr_l1_t01.dart
@@ -56,7 +56,7 @@
 
 main() {
   Expect.equals(
-    typeOf<A<FutureOr<dynamic>>>(),
+    typeOf<C<FutureOr<dynamic>>>(),
     typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_FutureOr_l1_t02.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_FutureOr_l1_t02.dart
index 2f38d56..24aee82 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_FutureOr_l1_t02.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_FutureOr_l1_t02.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks instantiation to bounds for [typedef A<X extends
- * FutureOr<A<X>>]
+ * FutureOr<C<X>> = C<X>]
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -52,11 +52,11 @@
 import "../../../../Utils/expect.dart";
 
 class C<X> {}
-typedef A<X extends FutureOr<A<X>>> = C<X>;
+typedef A<X extends FutureOr<C<X>>> = C<X>;
 
 main() {
   Expect.equals(
-    typeOf<A<FutureOr<A<dynamic>>>>(),
+    typeOf<C<FutureOr<C<dynamic>>>>(),
     typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t01.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t01.dart
index 188cfec..05cb714 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t01.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t01.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [typedef
- * A<X extends A<X>>]
+ * A<X extends C<X>> = C<X>]
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -51,11 +51,11 @@
 import "../../../../Utils/expect.dart";
 
 class C<X> {}
-typedef A<X extends A<X>> = C<X>;
+typedef A<X extends C<X>> = C<X>;
 
 main() {
   Expect.equals(
-    typeOf<A<A<dynamic>>>(),
+    typeOf<C<C<dynamic>>>(),
     typeOf<A>()
   );
 }
\ No newline at end of file
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t02.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t02.dart
index 44148c9..3cef42c 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t02.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t02.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks instantiation to bounds for [typedef A<X extends
- * A<A<X>>>]
+ * C<C<X>>> = C<X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -51,11 +51,11 @@
 import "../../../../Utils/expect.dart";
 
 class C<X> {}
-typedef A<X extends A<A<X>>> = C<X>;
+typedef A<X extends C<C<X>>> = C<X>;
 
 main() {
   Expect.equals(
-    typeOf<A<A<A<dynamic>>>>(),
+    typeOf<C<C<C<dynamic>>>>(),
     typeOf<A>()
   );
-}
\ No newline at end of file
+}
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t03.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t03.dart
index 7248af4..cbeb207 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t03.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t03.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiation to bounds works for [class A<X extends
- * A<X>>], [typedef B<X extends A<X>>]
+ * A<X>>; typedef B<X extends A<X>> = A<X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -55,7 +55,7 @@
 
 main() {
   Expect.equals(
-    typeOf<B<A<dynamic>>>(),
+    typeOf<A<A<dynamic>>>(),
     typeOf<B>(),
   );
 }
\ No newline at end of file
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t04.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t04.dart
index 7fc18fc..c0451af 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t04.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t04.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiation to bounds works for [class A<X extends
- * A<X>>], typedef B<X extends A<A<X>>>]
+ * A<X>>; typedef B<X extends A<A<X>>> = A<X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -55,7 +55,7 @@
 
 main() {
   Expect.equals(
-    typeOf<B<A<A<dynamic>>>>(),
+    typeOf<A<A<A<dynamic>>>>(),
     typeOf<B>(),
   );
 }
\ No newline at end of file
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t05.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t05.dart
index 3643aac..e527897 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t05.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t05.dart
@@ -42,20 +42,23 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiate-to-bounds works as expected for [typedef
- * O<X extends M<O<X>>>].
+ * @description Checks that instantiate-to-bounds works as expected for [class
+ * M<X>; class N<X extends M<N<X>>>; typedef O<X extends M<N<X>>> = M<N<X>>].
  * @author iarkh@unipro.ru
+ * @Issue 34726
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
 
 import "../../../../Utils/expect.dart";
 
 class M<X> {}
-typedef O<X extends M<O<X>>> = M<O<X>>;
+class N<X extends M<N<X>>> {}
+
+typedef O<X extends M<N<X>>> = M<N<X>>;
 
 main() {
   Expect.equals(
-    typeOf<O<M<O<dynamic>>>>(),
+    typeOf<M<N<M<dynamic>>>>(),
     typeOf<O>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t06.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t06.dart
index 5e2dbc6..86e9c21 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t06.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l1_t06.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks instantiation to bounds for the [typedef A<X extends
- * M<A<A<A<A<X>>>>>>]
+ * M<M<M<M<M<M<X>>>>>>> = M<M<X>>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -51,11 +51,11 @@
 import "../../../../Utils/expect.dart";
 
 class M<X> {}
-typedef A<X extends M<A<M<A<M<A<X>>>>>>> = M<A<X>>;
+typedef A<X extends M<M<M<M<M<M<X>>>>>>> = M<M<X>>;
 
 main() {
   Expect.equals(
-    typeOf<A<M<A<M<A<M<A<dynamic>>>>>>>>(),
+    typeOf<M<M<M<M<M<M<M<dynamic>>>>>>>>(),
     typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t01.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t01.dart
index 6d2f627..707e3d7 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t01.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t01.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [typedef
- * [A<X1 extends X2, X2 extends A<X1, X2>>]
+ * [A<X1 extends X2, X2 extends C<X1, X2>>]
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -51,11 +51,11 @@
 import "../../../../Utils/expect.dart";
 
 class C<X1, X2> {}
-typedef A<X1 extends X2, X2 extends A<X1, X2>> = C<X1, X2>;
+typedef A<X1 extends X2, X2 extends C<X1, X2>> = C<X1, X2>;
 
 main() {
   Expect.equals(
-    typeOf<A<dynamic, A<dynamic, dynamic>>>(),
+    typeOf<C<dynamic, C<dynamic, dynamic>>>(),
     typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t02.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t02.dart
index ff101fc..c8569b5 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t02.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t02.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [typedef
- * A<X1 extends A<X1, X2>, X2 extends X1>]
+ * A<X1 extends C<X1, X2>, X2 extends X1>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -51,11 +51,11 @@
 import "../../../../Utils/expect.dart";
 
 class C<X1, X2> {}
-typedef A<X1 extends A<X1, X2>, X2 extends X1> = C<X1, X2>;
+typedef A<X1 extends C<X1, X2>, X2 extends X1> = C<X1, X2>;
 
 main() {
   Expect.equals(
-      typeOf<A<A<dynamic, dynamic>, dynamic>>(),
+      typeOf<C<C<dynamic, dynamic>, dynamic>>(),
       typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t03.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t03.dart
index 0dba4e1..cda1822 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t03.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t03.dart
@@ -42,20 +42,22 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiate-to-bounds works as expected for [typedef
- * A<String, X extends A<Null, A<String,X>>>]
+ * @description Checks that instantiate-to-bounds works as expected for [class
+ * C<X1, X2>; typedef A<Y extends String, X extends C<Null, C<String, X>>> =
+ * C<Y, X>].
  * @author iarkh@unipro.ru
+ * @Issue 34727, 34948
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
 
 import "../../../../Utils/expect.dart";
 
 class C<X1, X2> {}
-typedef A<Y extends String, X extends A<Null, A<String, X>>> = C<Y, X>;
+typedef A<Y extends String, X extends C<Null, C<String, X>>> = C<Y, X>;
 
 main() {
   Expect.equals(
-    typeOf<A<String, A<Null, A<String, dynamic>>>>(),
+    typeOf<C<String, C<Null, C<String, dynamic>>>>(),
     typeOf<A>(),
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t04.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t04.dart
index c4d28a9..182dd75 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t04.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t04.dart
@@ -42,8 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiate-to-bounds works as expected for [typedef
- * A<String, X extends A<void, A<String,X>>>]
+ * @description Checks that instantiate-to-bounds works as expected for [class
+ * C<X, Y>; typedef A<Y extends String, X extends C<void, C<String, X>>> =
+ * C<Y, X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -52,11 +53,11 @@
 
 
 class C<X, Y> {}
-typedef A<Y extends String, X extends A<void, A<String, X>>> = C<Y, X>;
+typedef A<Y extends String, X extends C<void, C<String, X>>> = C<Y, X>;
 
 main() {
   Expect.equals(
-    typeOf<A<String, A<void, A<String, dynamic>>>>(),
+    typeOf<C<String, C<void, C<String, dynamic>>>>(),
     typeOf<A>(),
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t05.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t05.dart
index f78607a..4b29bec 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t05.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t05.dart
@@ -43,8 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [class
- * B<X extends B<X, Y>, Y>], [typedef A<X1 extends B<X1, X2>, X2 extends X1>].
-
+ * B<X extends B<X, Y>, Y>; typedef A<X1 extends B<X1, X2>, X2 extends X1>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t06.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t06.dart
index 0486f5d..d3f95b6 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t06.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t06.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [class
- * B<X extends B<X, Y>, Y>], [typedef A<X1 extends B<X1, X2>, X2>]
+ * B<X extends B<X, Y>, Y>; typedef A<X1 extends B<X1, X2>, X2>]
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -55,7 +55,7 @@
 
 main() {
   Expect.equals(
-    typeOf<A<B<dynamic, dynamic>, dynamic>>(),
+    typeOf<B<B<dynamic, dynamic>, dynamic>>(),
     typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t07.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t07.dart
index 8783289..5ef290c 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t07.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t07.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [class
- * B<X extends B<X>>], [typedef class A<X1, X2 extends B<X2>>]
+ * B<X extends B<X>>; typedef class A<X1, X2 extends B<X2>>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -55,7 +55,7 @@
 
 main() {
   Expect.equals(
-    typeOf<A<dynamic, B<dynamic, dynamic>>>(),
+    typeOf<B<dynamic, B<dynamic, dynamic>>>(),
     typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t09.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t09.dart
index 3cd6a2e..a8c77c1 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t09.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t09.dart
@@ -43,8 +43,8 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [class
- * B<X extends B<X>>], [class C<X, Y>], [typedef A<X1 extends B<X2>, X2 extends
- * B<X2>>]
+ * B<X extends B<X>>; class C<X, Y>; typedef A<X1 extends B<X2>, X2 extends
+ * B<X2>> = C<X1, X2>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -57,7 +57,7 @@
 
 main() {
   Expect.equals(
-      typeOf<A<B<B<dynamic>>, B<dynamic>>>(),
+      typeOf<C<B<B<dynamic>>, B<dynamic>>>(),
       typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t10.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t10.dart
index 2e5bae7..3975bc9 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t10.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l2_t10.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [typedef
- * A<X1 extends A<X1, X2>, X2 extends A<X1, X2>>]
+ * A<X1 extends B<X1, X2>, X2 extends B<X1, X2>>]
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -51,11 +51,11 @@
 import "../../../../Utils/expect.dart";
 
 class B<X, Y> {}
-typedef A<X1 extends A<X1, X2>, X2 extends A<X1, X2>> = B<X1, X2>;
+typedef A<X1 extends B<X1, X2>, X2 extends B<X1, X2>> = B<X1, X2>;
 
 main() {
   Expect.equals(
-      typeOf<A<A<dynamic, dynamic>, A<dynamic, dynamic>>>(),
+      typeOf<B<B<dynamic, dynamic>, B<dynamic, dynamic>>>(),
       typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l3_t01.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l3_t01.dart
index 889a9ce..406054b 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l3_t01.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l3_t01.dart
@@ -42,8 +42,8 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiate-to-bounds works as expected for the
- *  class [G<X1 extends X2, X2 extends X3, X3 extends G<X1, X2, X3>>]
+ * @description Checks that instantiate-to-bounds works as expected for [typedef
+ * G<X1 extends X2, X2 extends X3, X3 extends A<X1, X2, X3>>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -51,11 +51,11 @@
 import "../../../../Utils/expect.dart";
 
 class A<X, Y, Z> {}
-typedef G<X1 extends X2, X2 extends X3, X3 extends G<X1, X2, X3>> = A<X1, X2, X3>;
+typedef G<X1 extends X2, X2 extends X3, X3 extends A<X1, X2, X3>> = A<X1, X2, X3>;
 
 main() {
   Expect.equals(
-    typeOf<G<dynamic, dynamic, G<dynamic, dynamic, dynamic>>>(),
+    typeOf<A<dynamic, dynamic, A<dynamic, dynamic, dynamic>>>(),
     typeOf<G>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l4_t01.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l4_t01.dart
index a8fc7b1..3d38b32 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l4_t01.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_l4_t01.dart
@@ -43,8 +43,8 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [class
- * A<X>], [class B<X> extends A<X>], [class C<X1, X2, X3, X4>], [typedef G<X1
- * extends A<X1>, X2 extends A<X1>, X3 extends B, X4 extends X2>]
+ * A<X>; class B<X> extends A<X>; class C<X1, X2, X3, X4>; typedef G<X1 extends
+ * A<X1>, X2 extends A<X1>, X3 extends B, X4 extends X2> = C<X1, X2, X3, X4>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -60,7 +60,7 @@
 
 main() {
   Expect.equals(
-    typeOf<G<A<dynamic>, A<A<dynamic>>, B<dynamic>, A<A<dynamic>>>>(),
+    typeOf<C<A<dynamic>, A<A<dynamic>>, B<dynamic>, A<A<dynamic>>>>(),
     typeOf<G>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l1_t01.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l1_t01.dart
index deb3bad..2981e5e 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l1_t01.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l1_t01.dart
@@ -42,8 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiation to bounds works OK for the
- * non-function typedef with [X Function()] parameter (covariant)
+ * @description Checks that instantiation to bounds works OK for non-function
+ * typedef with [X Function()] type parameter: [typedef G<X> = X Function();
+ * class C<X>; typedef A<X extends G<С<X>>> = C<X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -53,11 +54,11 @@
 typedef G<X> = X Function();
 class C<X> {}
 
-typedef A<X extends G<A<X>>> = C<X>;
+typedef A<X extends G<С<X>>> = C<X>;
 
 main() {
   Expect.equals(
-    typeOf<A<G<A<dynamic>>>>(),
+    typeOf<С<G<C<dynamic>>>>(),
     typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l1_t02.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l1_t02.dart
index 3aba5e0..d85734b 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l1_t02.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l1_t02.dart
@@ -43,7 +43,8 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiation to bounds works OK for non-function
- * typedef with [typedef G<X> = Function(X)] parameter (contravariant)
+ * typedef with [typedef G<X> = Function(X)] type parameter: [typedef G<X> =
+ * void Function(X); class C<X>; typedef A<X extends G<C<X>>> = C<X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -53,11 +54,11 @@
 typedef G<X> = void Function(X);
 class C<X> {}
 
-typedef A<X extends G<A<X>>> = C<X>;
+typedef A<X extends G<C<X>>> = C<X>;
 
 main() {
   Expect.equals(
-      typeOf<A<G<C<Null>>>>(),
+      typeOf<C<G<C<Null>>>>(),
       typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l1_t04.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l1_t04.dart
index 14146ec..60ba372 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l1_t04.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l1_t04.dart
@@ -43,7 +43,8 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiation to bounds works OK for non-function
- * typedef with [typedef G<X> = void Function()] parameter (not used)
+ * typedef with [typedef G<X> = void Function()] type parameter: [typedef G<X> =
+ * void Function(); class C<X>; typedef A<X extends G<C<X>>> = C<X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -57,7 +58,7 @@
 
 main() {
   Expect.equals(
-      typeOf<A<G<C<dynamic>>>>(),
+      typeOf<C<G<C<dynamic>>>>(),
       typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t01.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t01.dart
index 987cb70..dfcec23 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t01.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t01.dart
@@ -43,8 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiation to bounds works OK for [typedef G<X> =
- * X Function()], [class C<X, Y>], [typedef A<X extends G<A<X, Y>>, Y extends
- * X>] (covariant)
+ * X Function(); class C<X, Y>; typedef A<X extends G<C<X, Y>>, Y extends X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -57,7 +56,7 @@
 
 main() {
   Expect.equals(
-      typeOf<A<G<C<dynamic, dynamic>>, dynamic>>(),
+      typeOf<C<G<C<dynamic, dynamic>>, dynamic>>(),
       typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t02.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t02.dart
index 543fe80..1468820 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t02.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t02.dart
@@ -43,8 +43,8 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiation to bounds works OK for [typedef G<X> =
- * Function(X)], [class C<X, Y>], [typedef A<X extends G<A<X,Y>>, Y extends X> =
- * C<X, Y>] (covariant)
+ * Function(X); class C<X, Y>; typedef A<X extends G<A<X,Y>>, Y extends X> =
+ * C<X, Y>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -57,7 +57,7 @@
 
 main() {
   Expect.equals(
-      typeOf<A<G<C<Null, Null>>, dynamic>>(),
+      typeOf<C<G<C<Null, Null>>, dynamic>>(),
       typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t04.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t04.dart
index fb4c3dc..2d0a61f 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t04.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t04.dart
@@ -42,9 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiation to bounds works OK for [class C<X, Y>],
-    [typedef G<X> = void Function()], [typedef A<X extends G<C<X,Y>>, Y extends
-    X> = C<X, Y>] (unused)
+ * @description Checks that instantiation to bounds works OK for [class C<X, Y>;
+ * typedef G<X> = void Function(); typedef A<X extends G<C<X,Y>>, Y extends X> =
+ * C<X, Y>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -57,7 +57,7 @@
 
 main() {
   Expect.equals(
-      typeOf<A<G<C<dynamic, dynamic>>, dynamic>>(),
+      typeOf<C<G<C<dynamic, dynamic>>, dynamic>>(),
       typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t05.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t05.dart
index 61e21c8..df8db90 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t05.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t05.dart
@@ -42,9 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiation to bounds works OK for [class C<X,
- * Y>], [typedef G<X> = X Function()], [typedef A<X extends G<A<Y, X>>, Y
- * extends G<A<X, Y>>> = C<X, Y>]
+ * @description Checks that instantiation to bounds works OK for [class C<X,Y>;
+ * typedef G<X> = X Function(); typedef A<X extends G<A<Y, X>>, Y extends G<A<X,
+ * Y>>> = C<X, Y>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -57,7 +57,7 @@
 
 main() {
   Expect.equals(
-      typeOf<A<G<C<dynamic, dynamic>>, G<A<dynamic, dynamic>>>>(),
+      typeOf<C<G<C<dynamic, dynamic>>, G<C<dynamic, dynamic>>>>(),
       typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t06.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t06.dart
index fac0705..3372f76 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t06.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t06.dart
@@ -42,8 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiation to bounds works OK for [typedef G<X> =
- * Function(X)], [class A<X extends G<A<Y, X>>, Y extends G<A<X, Y>>>]
+ * @description Checks that instantiation to bounds works OK for [class C<X, Y>;
+ * typedef G<X> = Function(X); typedef A<X extends G<C<Y, X>>, Y extends G<C<X,
+ * Y>>> = C<X, Y>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -56,7 +57,7 @@
 
 main() {
   Expect.equals(
-      typeOf<A<G<C<Null, Null>>, G<C<Null, Null>>>>(),
+      typeOf<C<G<C<Null, Null>>, G<C<Null, Null>>>>(),
       typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t08.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t08.dart
index 9a2b4a7..7307361 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t08.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/dynamic/nonfunction_typedef_l2_t08.dart
@@ -42,8 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiation to bounds works OK for [typedef G<X> =
- * void Function()], [class A<X extends G<A<Y, X>>, Y extends G<A<X, Y>>>]
+ * @description Checks that instantiation to bounds works OK for [class C<X, Y>;
+ * typedef G<X> = void Function(); typedef A<X extends G<C<Y, X>>, Y extends
+ * G<C<X, Y>>> = C<X, Y>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -56,7 +57,7 @@
 
 main() {
   Expect.equals(
-      typeOf<A<G<C<dynamic, dynamic>>, G<C<dynamic, dynamic>>>>(),
+      typeOf<C<G<C<dynamic, dynamic>>, G<C<dynamic, dynamic>>>>(),
       typeOf<A>()
   );
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_FutureOr_l1_t02.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_FutureOr_l1_t02.dart
index e28dc8f..79b2bfb 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_FutureOr_l1_t02.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_FutureOr_l1_t02.dart
@@ -42,8 +42,8 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiate-to-bounds works as expected for [A<X
- * extends FutureOr<A<X>>]
+ * @description Checks that instantiate-to-bounds works as expected for [typedef
+ * A<X extends FutureOr<C<X>>]
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -55,17 +55,17 @@
 
 // Probably does not work here because of the issue 34264
 class C<X> {}
-typedef A<X extends FutureOr<A<X>>> = C<X>;
+typedef A<X extends FutureOr<C<X>>> = C<X>;
 
 main() {
   A source;
   var fsource = toF(source);
-  F<A<FutureOr<A<dynamic>>>> target = fsource;
+  F<A<FutureOr<C<dynamic>>>> target = fsource;
 
   F<A<dynamic>> target1 = fsource;                           //# 01: compile-time error
   F<A<FutureOr<dynamic>>> target2 = fsource;                 //# 02: compile-time error
-  F<A<FutureOr<A<FutureOr<dynamic>>>>> target3 = fsource;    //# 03: compile-time error
-  F<A<FutureOr<A<FutureOr<A<dynamic>>>>>> target4 = fsource; //# 04: compile-time error
+  F<A<FutureOr<C<FutureOr<dynamic>>>>> target3 = fsource;    //# 03: compile-time error
+  F<A<FutureOr<C<FutureOr<C<dynamic>>>>>> target4 = fsource; //# 04: compile-time error
 
-  A(); //# 05: compile-time error
+  A();                                                       //# 05: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t01.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t01.dart
index 87c8a16..fd1d8f1 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t01.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t01.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for
- * [typedef A<X extends A<X>>]
+ * [typedef A<X extends C<X>> = C<X>]
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -52,17 +52,17 @@
 F<X> toF<X>(X x) => null;
 
 class C<X> {}
-typedef A<X extends A<X>> = C<X>;
+typedef A<X extends C<X>> = C<X>;
 
 main() {
   A source;
   var fsource = toF(source);
-  F<A<A<dynamic>>> target = fsource;
+  F<A<C<dynamic>>> target = fsource;
 
   F<A<dynamic>> target1 = fsource;             //# 01: compile-time error
-  F<A<A<A<dynamic>>>> target2 = fsource;       //# 02: compile-time error
-  F<A<A<A<A<dynamic>>>>> target3 = fsource;    //# 03: compile-time error
-  F<A<A<A<A<A<dynamic>>>>>> target4 = fsource; //# 04: compile-time error
+  F<A<C<C<dynamic>>>> target2 = fsource;       //# 02: compile-time error
+  F<A<C<C<C<dynamic>>>>> target3 = fsource;    //# 03: compile-time error
+  F<A<C<C<C<C<dynamic>>>>>> target4 = fsource; //# 04: compile-time error
 
-  A();  //# 05: compile-time error
+  A();                                         //# 05: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t02.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t02.dart
index 5013beb..185ac10 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t02.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t02.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiation to bounds works OK for [typedef A<X
- * extends A<A<X>>>]
+ * extends C<C<X>>> = C<X>]
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -52,23 +52,23 @@
 F<X> toF<X>(X x) => null;
 
 class C<X> {}
-typedef A<X extends A<A<X>>> = C<X>;
+typedef A<X extends C<C<X>>> = C<X>;
 
 main() {
   A source;
   var fsource = toF(source);
 
-  F<A<A<A<dynamic>>>> target = fsource;
+  F<A<C<C<dynamic>>>> target = fsource;
 
   F<A<dynamic>> target1 = fsource;             //# 01: compile-time error
-  F<A<A<dynamic>>> target2 = fsource;          //# 02: compile-time error
-  F<A<A<A<A<dynamic>>>>> target3 = fsource;    //# 03: compile-time error
-  F<A<A<A<A<A<dynamic>>>>>> target4 = fsource; //# 04: compile-time error
+  F<A<C<dynamic>>> target2 = fsource;          //# 02: compile-time error
+  F<A<C<C<C<dynamic>>>>> target3 = fsource;    //# 03: compile-time error
+  F<A<C<C<C<C<dynamic>>>>>> target4 = fsource; //# 04: compile-time error
 
-  F<A<Null>> target5 = fsource;             //# 05: compile-time error
-  F<A<A<Null>>> target6 = fsource;          //# 06: compile-time error
-  F<A<A<A<A<Null>>>>> target7 = fsource;    //# 07: compile-time error
-  F<A<A<A<A<A<Null>>>>>> target8 = fsource; //# 08: compile-time error
+  F<A<Null>> target5 = fsource;                //# 05: compile-time error
+  F<A<C<Null>>> target6 = fsource;             //# 06: compile-time error
+  F<A<C<C<C<Null>>>>> target7 = fsource;       //# 07: compile-time error
+  F<A<C<C<C<C<Null>>>>>> target8 = fsource;    //# 08: compile-time error
 
-  A(); //# 09: compile-time error
+  A();                                         //# 09: compile-time error
 }
\ No newline at end of file
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t03.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t03.dart
index 92980d7..2b5a44f 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t03.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t03.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiation to bounds works as expected for
- * [class A<X extends A<X>>], [class B<X extends A<X>>]
+ * [class A<X extends A<X>>; typedef B<X extends A<X>>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -65,11 +65,11 @@
   F<B<A<A<A<dynamic>>>>> target3 = fsource;    //# 03: compile-time error
   F<B<A<A<A<A<dynamic>>>>>> target4 = fsource; //# 04: compile-time error
 
-  F<B<Null>> target5 = fsource;             //# 05: compile-time error
-  F<B<A<Null>>> target6 = fsource;          //# 06: compile-time error
-  F<B<A<A<Null>>>> target7 = fsource;       //# 07: compile-time error
-  F<B<A<A<A<Null>>>>> target8 = fsource;    //# 08: compile-time error
-  F<B<A<A<A<A<Null>>>>>> target9 = fsource; //# 09: compile-time error
+  F<B<Null>> target5 = fsource;                //# 05: compile-time error
+  F<B<A<Null>>> target6 = fsource;             //# 06: compile-time error
+  F<B<A<A<Null>>>> target7 = fsource;          //# 07: compile-time error
+  F<B<A<A<A<Null>>>>> target8 = fsource;       //# 08: compile-time error
+  F<B<A<A<A<A<Null>>>>>> target9 = fsource;    //# 09: compile-time error
 
-  B(); //# 10: compile-time error
+  B();                                         //# 10: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t04.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t04.dart
index 633fbe1..be8c820 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t04.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t04.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiation to bounds works as expected for
- * [class A<X extends A<X>>], [class B<X extends A<A<X>>>]
+ * [class A<X extends A<X>>; typedef B<X extends A<A<X>>> = A<X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -65,11 +65,11 @@
   F<B<A<A<A<dynamic>>>>> target3 = fsource;    //# 03: compile-time error
   F<B<A<A<A<A<dynamic>>>>>> target4 = fsource; //# 04: compile-time error
 
-  F<B<Null>> target5 = fsource;             //# 05: compile-time error
-  F<B<A<Null>>> target6 = fsource;          //# 06: compile-time error
-  F<B<A<A<Null>>>> target7 = fsource;       //# 07: compile-time error
-  F<B<A<A<A<Null>>>>> target8 = fsource;    //# 08: compile-time error
-  F<B<A<A<A<A<Null>>>>>> target9 = fsource; //# 09: compile-time error
+  F<B<Null>> target5 = fsource;                //# 05: compile-time error
+  F<B<A<Null>>> target6 = fsource;             //# 06: compile-time error
+  F<B<A<A<Null>>>> target7 = fsource;          //# 07: compile-time error
+  F<B<A<A<A<Null>>>>> target8 = fsource;       //# 08: compile-time error
+  F<B<A<A<A<A<Null>>>>>> target9 = fsource;    //# 09: compile-time error
 
-  B(); //# 10: compile-time error
+  B();                                         //# 10: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t05.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t05.dart
index a751dfb..adaf29f 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t05.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t05.dart
@@ -42,8 +42,8 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiate-to-bounds works as expected for the
- * class [O<X extends M<O<X>>>].
+ * @description Checks that instantiate-to-bounds works as expected for [class
+ * M<X>; class N<X extends M<N<X>>>; typedef O<X extends M<N<X>>> = M<N<X>>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -52,24 +52,26 @@
 F<X> toF<X>(X x) => null;
 
 class M<X> {}
-typedef O<X extends M<O<X>>> = M<O<X>>;
+class N<X extends M<N<X>>> {}
+
+typedef O<X extends M<N<X>>> = M<N<X>>;
 
 main() {
   O source;
   var fsource = toF(source);
 
-  F<O<M<O<dynamic>>>> target = fsource;
+  F<O<M<N<M<dynamic>>>>> target = fsource;
 
   F<O<dynamic>> target1 = fsource;             //# 01: compile-time error
   F<O<M<dynamic>>> target2 = fsource;          //# 02: compile-time error
-  F<O<M<O<M<dynamic>>>>> target3 = fsource;    //# 03: compile-time error
-  F<O<M<O<M<O<dynamic>>>>>> target4 = fsource; //# 04: compile-time error
+  F<O<M<N<dynamic>>>> target3 = fsource;       //# 03: compile-time error
+  F<O<M<N<M<N<dynamic>>>>>> target4 = fsource; //# 04: compile-time error
 
-  F<O<Null>> target5 = fsource;             //# 05: compile-time error
-  F<O<M<Null>>> target6 = fsource;          //# 06: compile-time error
-  F<O<M<O<Null>>>> target7 = fsource;       //# 07: compile-time error
-  F<O<M<O<M<Null>>>>> target8 = fsource;    //# 08: compile-time error
-  F<O<M<O<M<O<Null>>>>>> target9 = fsource; //# 09: compile-time error
+  F<O<Null>> target5 = fsource;                //# 05: compile-time error
+  F<O<M<Null>>> target6 = fsource;             //# 06: compile-time error
+  F<O<M<N<Null>>>> target7 = fsource;          //# 07: compile-time error
+  F<O<M<N<M<Null>>>>> target8 = fsource;       //# 08: compile-time error
+  F<O<M<N<M<N<Null>>>>>> target9 = fsource;    //# 09: compile-time error
 
-  O(); //# 10: compile-time error
+  O();                                         //# 10: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t06.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t06.dart
index 0c38aec..ebffc16 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t06.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l1_t06.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [typedef
- * O<X extends M<O<M<O<M<O<X>>>>>>>].
+ * O<X extends M<M<M<M<M<M<X>>>>>>> = M<M<X>>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -52,28 +52,28 @@
 F<X> toF<X>(X x) => null;
 
 class M<X> {}
-typedef O<X extends M<O<M<O<M<O<X>>>>>>> = M<O<X>>;
+typedef O<X extends M<M<M<M<M<M<X>>>>>>> = M<M<X>>;
 
 main() {
   O source;
   var fsource = toF(source);
 
-  F<O<M<O<M<O<M<O<dynamic>>>>>>>> target = fsource;
+  F<O<M<M<M<M<M<M<dynamic>>>>>>>> target = fsource;
 
-  F<O<dynamic>> target1 = fsource;                //# 01: compile-time error
-  F<O<M<dynamic>>> target2 = fsource;             //# 02: compile-time error
-  F<O<M<O<M<dynamic>>>>> target3 = fsource;       //# 03: compile-time error
-  F<O<M<O<M<O<dynamic>>>>>> target4 = fsource;    //# 04: compile-time error
-  F<O<M<O<M<O<M<dynamic>>>>>>> target5 = fsource; //# 05: compile-time error
+  F<O<dynamic>> target1 = fsource;                         //# 01: compile-time error
+  F<O<M<dynamic>>> target2 = fsource;                      //# 02: compile-time error
+  F<O<M<M<M<dynamic>>>>> target3 = fsource;                //# 03: compile-time error
+  F<O<M<M<M<M<dynamic>>>>>> target4 = fsource;             //# 04: compile-time error
+  F<O<M<M<M<M<M<dynamic>>>>>>> target5 = fsource;          //# 05: compile-time error
 
-  F<O<M<O<M<O<M<O<M<dynamic>>>>>>>>> target6 = fsource;    //# 06: compile-time error
-  F<O<M<O<M<O<M<O<M<O<dynamic>>>>>>>>>> target7 = fsource; //# 07: compile-time error
+  F<O<M<M<M<M<M<M<M<dynamic>>>>>>>>> target6 = fsource;    //# 06: compile-time error
+  F<O<M<M<M<M<M<M<M<M<dynamic>>>>>>>>>> target7 = fsource; //# 07: compile-time error
 
-  F<O<Null>> target8 = fsource;              //# 08: compile-time error
-  F<O<M<Null>>> target9  = fsource;          //# 09: compile-time error
-  F<O<M<O<Null>>>> target10 = fsource;       //# 10: compile-time error
-  F<O<M<O<M<Null>>>>> target11 = fsource;    //# 11: compile-time error
-  F<O<M<O<M<O<Null>>>>>> target12 = fsource; //# 12: compile-time error
+  F<O<Null>> target8 = fsource;                            //# 08: compile-time error
+  F<O<M<Null>>> target9  = fsource;                        //# 09: compile-time error
+  F<O<M<M<Null>>>> target10 = fsource;                     //# 10: compile-time error
+  F<O<M<M<M<Null>>>>> target11 = fsource;                  //# 11: compile-time error
+  F<O<M<M<M<M<Null>>>>>> target12 = fsource;               //# 12: compile-time error
 
-  O(); //# 13: compile-time error
+  O();                                                     //# 13: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t01.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t01.dart
index 463b8b8..64614bf 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t01.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t01.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [typedef
- * A<X1 extends X2, X2 extends A<X1, X2>>]
+ * A<X1 extends X2, X2 extends C<X1, X2>>]
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -52,16 +52,16 @@
 F<X> toF<X>(X x) => null;
 
 class C<X1, X2> {}
-typedef A<X1 extends X2, X2 extends A<X1, X2>> = C<X1, X2>;
+typedef A<X1 extends X2, X2 extends C<X1, X2>> = C<X1, X2>;
 
 main() {
   A source;
   var fsource = toF(source);
 
-  F<A<dynamic, A<dynamic, dynamic>>> target = fsource;
+  F<A<dynamic, C<dynamic, dynamic>>> target = fsource;
 
   F<A<dynamic, dynamic>> target1 = fsource;                         //# 01: compile-time error
-  F<A<A<dynamic, dynamic>, A<dynamic, dynamic>>> target2 = fsource; //# 02: compile-time error
+  F<A<C<dynamic, dynamic>, C<dynamic, dynamic>>> target2 = fsource; //# 02: compile-time error
 
   A(); //# 03: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t02.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t02.dart
index 324fe2e..03235f1 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t02.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t02.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [typedef
- * [A<X1 extends A<X1, X2>, X2 extends X1>]
+ * [A<X1 extends C<X1, X2>, X2 extends X1>]
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -52,16 +52,16 @@
 F<X> toF<X>(X x) => null;
 
 class C<X1, X2> {}
-typedef A<X1 extends A<X1, X2>, X2 extends X1> = C<X1, X2>;
+typedef A<X1 extends C<X1, X2>, X2 extends X1> = C<X1, X2>;
 
 main() {
   A source;
   var fsource = toF(source);
 
-  F<A<A<dynamic, dynamic>, dynamic>> target = fsource;
+  F<A<C<dynamic, dynamic>, dynamic>> target = fsource;
 
   F<A<dynamic, dynamic>> target1 = fsource;             //# 01: compile-time error
-  F<A<dynamic, A<dynamic, dynamic>>> target2 = fsource; //# 02: compile-time error
+  F<A<dynamic, C<dynamic, dynamic>>> target2 = fsource; //# 02: compile-time error
 
   A(); //# 03: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t03.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t03.dart
index b8ba61e..56e6197 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t03.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t03.dart
@@ -42,8 +42,10 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiate-to-bounds works as expected for [typedef
- * A<String, X extends A<Null, A<String,X>>>]
+ * @description Checks that instantiate-to-bounds works as expected for [class
+ * C<X1, X2>; typedef A<Y extends String, X extends C<Null, C<String, X>>> =
+ * C<Y, X>].
+ * @Issue 34727, 34948
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -52,16 +54,16 @@
 F<X> toF<X>(X x) => null;
 
 class C<X1, X2> {}
-typedef A<Y extends String, X extends A<Null, A<String, X>>> = C<Y, X>;
+typedef A<Y extends String, X extends C<Null, C<String, X>>> = C<Y, X>;
 
 main() {
   A source;
   var fsource = toF(source);
 
-  F<A<String, A<Null, A<String, dynamic>>>> target = fsource;
+  F<A<String, A<Null, C<String, dynamic>>>> target = fsource;
 
   F<A<dynamic, dynamic>> target1 = fsource;                         //# 01: compile-time error
-  F<A<dynamic, A<dynamic, A<dynamic, dynamic>>>> target2 = fsource; //# 02: compile-time error
+  F<A<dynamic, C<dynamic, C<dynamic, dynamic>>>> target2 = fsource; //# 02: compile-time error
 
-  A(); //# 03: compile-time error
+  A();                                                              //# 03: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t04.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t04.dart
index 382d8b9..2c39ca6 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t04.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t04.dart
@@ -42,8 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiate-to-bounds works as expected for [typedef
- * A<String, X extends A<void, A<String,X>>>]
+ * @description Checks that instantiate-to-bounds works as expected for [class
+ * C<X, Y>; typedef A<Y extends String, X extends C<void, C<String, X>>> = C<Y,
+ * X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -52,16 +53,16 @@
 F<X> toF<X>(X x) => null;
 
 class C<X, Y> {}
-typedef A<Y extends String, X extends A<void, A<String, X>>> = C<Y, X>;
+typedef A<Y extends String, X extends C<void, C<String, X>>> = C<Y, X>;
 
 main() {
   A source;
   var fsource = toF(source);
 
-  F<A<String, A<void, A<String, dynamic>>>> target = fsource;
+  F<A<String, C<void, C<String, dynamic>>>> target = fsource;
 
   F<A<dynamic, dynamic>> target1 = fsource;                         //# 01: compile-time error
-  F<A<dynamic, A<dynamic, A<dynamic, dynamic>>>> target2 = fsource; //# 02: compile-time error
+  F<A<dynamic, C<dynamic, C<dynamic, dynamic>>>> target2 = fsource; //# 02: compile-time error
 
-  A(); //# 03: compile-time error
+  A();                                                              //# 03: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t05.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t05.dart
index 6ceaf4c..1ed4959 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t05.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t05.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [typedef
- * A<X1 extends X2, X2 extends A<X1, X2>>]
+ * A<X1 extends X2, X2 extends B<X1, X2>>]
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t06.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t06.dart
index 7a206e8..dcf167c 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t06.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t06.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [class
- * B<X extends B<X>>], [class A<X1 extends B<X1>, X2>]
+ * B<X extends B<X>>; class A<X1 extends B<X1>, X2>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t07.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t07.dart
index d57ba36..a4a6074 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t07.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t07.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [class
- * B<X extends B<X, Y>, Y>], [typedef A<X1, X2 extends B<X2, X1>>]
+ * B<X extends B<X, Y>, Y>; typedef A<X1, X2 extends B<X2, X1>>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t09.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t09.dart
index d79207d..e82e3f8 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t09.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t09.dart
@@ -43,8 +43,8 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [class
- * B<X extends B<X>>], [class C<X, Y>], [typedef A<X1 extends B<X2>, X2 extends
- * B<X2>>]
+ * B<X extends B<X>>; class C<X, Y>; typedef A<X1 extends B<X2>, X2 extends
+ * B<X2>> = C<X1, X2>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t10.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t10.dart
index f0b600b..9a36020 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t10.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l2_t10.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [typedef
- * A<X1 extends A<X1, X2>, X2 extends A<X1, X2>>]
+ * A<X1 extends B<X1, X2>, X2 extends B<X1, X2>>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -52,13 +52,13 @@
 F<X> toF<X>(X x) => null;
 
 class B<X, Y> {}
-typedef A<X1 extends A<X1, X2>, X2 extends A<X1, X2>> = B<X1, X2>;
+typedef A<X1 extends B<X1, X2>, X2 extends B<X1, X2>> = B<X1, X2>;
 
 main() {
   A source;
   var fsource = toF(source);
 
-  F<A<A<dynamic, dynamic>, A<dynamic, dynamic>>> target = fsource;
+  F<A<B<dynamic, dynamic>, B<dynamic, dynamic>>> target = fsource;
 
   F<A<dynamic, dynamic>> target1 = fsource; //# 01: compile-time error
   A();                                      //# 02: compile-time error
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l3_t01.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l3_t01.dart
index dd214c2..e97be16 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l3_t01.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l3_t01.dart
@@ -43,8 +43,8 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiate-to-bounds works as expected for [typedef
- * G<X1 extends X2, X2 extends X3, X3 extends G<X1, X2, X3>>]
- *  extends X2, X2 extends A<X1, X2>>]
+ * G<X1 extends X2, X2 extends X3, X3 extends A<X1, X2, X3>>].
+ *  extends X2, X2 extends A<X1, X2>>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -53,15 +53,14 @@
 F<X> toF<X>(X x) => null;
 
 class A<X, Y, Z> {}
-typedef G<X1 extends X2, X2 extends X3, X3 extends G<X1, X2, X3>> = A<X1, X2, X3>;
+typedef G<X1 extends X2, X2 extends X3, X3 extends A<X1, X2, X3>> = A<X1, X2, X3>;
 
 main() {
-  A source;
+  G source;
   var fsource = toF(source);
 
-  F<A<dynamic, dynamic, A<dynamic, dynamic, dynamic>>> target = fsource;
+  F<G<dynamic, dynamic, A<dynamic, dynamic, dynamic>>> target = fsource;
+  F<G<dynamic, dynamic, dynamic>> target1 = fsource; //# 01: compile-time error
 
-  F<A<dynamic, dynamic, dynamic>> target1 = fsource;  //# 01: compile-time error
-
-  A();                                                //# 02: compile-time error
+  A();                                               //# 02: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l4_t01.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l4_t01.dart
index 8798e602..a55bd17 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l4_t01.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_l4_t01.dart
@@ -42,8 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiate-to-bounds works as expected for [typedef
- * G<X1 extends A<X1>, X2 extends A<X1>, X3 extends B, X4 extends X2>]
+ * @description Checks that instantiate-to-bounds works as expected for [class
+ * A<X>; class B<X> extends A<X>; class C<X1, X2, X3, X4>; typedef G<X1 extends
+ * A<X1>, X2 extends A<X1>, X3 extends B, X4 extends X2> = C<X1, X2, X3, X4>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t01.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t01.dart
index 854e307..a99f544 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t01.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t01.dart
@@ -42,8 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiation to bounds works OK for the class with
- * [typedef G<X> = X Function()] parameter (covariant)
+ * @description Checks that instantiation to bounds works OK for non-function
+ * typedef with [X Function()] type parameter: [typedef G<X> = X Function();
+ * class C<X>; typedef A<X extends G<С<X>>> = C<X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -54,24 +55,24 @@
 typedef G<X> = X Function();
 class C<X> {}
 
-typedef A<X extends G<A<X>>> = C<X>;
+typedef A<X extends G<C<X>>> = C<X>;
 
 main() {
   A source;
   var fsource = toF(source);
-  F<A<G<A<dynamic>>>> target = fsource;
+  F<A<G<C<dynamic>>>> target = fsource;
 
-  F<A<G<A<Null>>>> target0 = fsource;          //# 01: compile-time error
+  F<A<G<C<Null>>>> target0 = fsource;          //# 01: compile-time error
 
   F<A<dynamic>> target1 = fsource;             //# 02: compile-time error
   F<A<G<dynamic>>> target2 = fsource;          //# 03: compile-time error
-  F<A<G<A<G<dynamic>>>>> target3 = fsource;    //# 04: compile-time error
-  F<A<G<A<G<A<dynamic>>>>>> target4 = fsource; //# 05: compile-time error
+  F<A<G<C<G<dynamic>>>>> target3 = fsource;    //# 04: compile-time error
+  F<A<G<C<G<C<dynamic>>>>>> target4 = fsource; //# 05: compile-time error
 
   F<A<Null>> target5 = fsource;                //# 06: compile-time error
   F<A<G<Null>>> target6 = fsource;             //# 07: compile-time error
-  F<A<G<A<G<Null>>>>> target7 = fsource;       //# 08: compile-time error
-  F<A<G<A<G<A<Null>>>>>> target8 = fsource;    //# 09: compile-time error
+  F<A<G<C<G<Null>>>>> target7 = fsource;       //# 08: compile-time error
+  F<A<G<C<G<C<Null>>>>>> target8 = fsource;    //# 09: compile-time error
 
   A();                                         //# 10: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t02.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t02.dart
index 3d87c2e..207bbc1 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t02.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t02.dart
@@ -42,8 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiation to bounds works OK for the class with
- * [typedef G<X> = Function(X)] parameter (contravariant)
+ * @description Checks that instantiation to bounds works OK for non-function
+ * typedef with [typedef G<X> = Function(X)] type parameter: [typedef G<X> =
+ * void Function(X); class C<X>; typedef A<X extends G<C<X>>> = C<X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -54,7 +55,7 @@
 typedef G<X> = void Function(X);
 class C<X> {}
 
-typedef A<X extends G<A<X>>> = C<X>;
+typedef A<X extends G<C<X>>> = C<X>;
 
 main() {
   A source;
@@ -64,12 +65,12 @@
   F<A<dynamic>> target1 = fsource;             //# 01: compile-time error
   F<A<G<dynamic>>> target2 = fsource;          //# 02: compile-time error
   F<A<G<C<G<dynamic>>>>> target3 = fsource;    //# 03: compile-time error
-  F<A<G<C<G<A<dynamic>>>>>> target4 = fsource; //# 04: compile-time error
+  F<A<G<C<G<C<dynamic>>>>>> target4 = fsource; //# 04: compile-time error
 
   F<A<Null>> target5 = fsource;                //# 05: compile-time error
   F<A<G<Null>>> target6 = fsource;             //# 06: compile-time error
-  F<A<G<A<G<Null>>>>> target7 = fsource;       //# 07: compile-time error
-  F<A<G<A<G<A<Null>>>>>> target8 = fsource;    //# 08: compile-time error
+  F<A<G<C<G<Null>>>>> target7 = fsource;       //# 07: compile-time error
+  F<A<G<C<G<C<Null>>>>>> target8 = fsource;    //# 08: compile-time error
 
   A();                                         //# 09: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t03.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t03.dart
index 1be837d..9869c1b 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t03.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t03.dart
@@ -43,14 +43,14 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiation to bounds works OK for [typedef G<X> =
- * X Function(X)], [class C<X>], [typedef A<X extends G<A<X>>>]
+ * X Function(X); class C<X>; typedef A<X extends G<C<X>>>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
 
 typedef G<X> = X Function(X);
 class C<X> {}
-typedef A<X extends G<A<X>>> = C<X>;
+typedef A<X extends G<C<X>>> = C<X>;
 
 main() {
   A source; //# 01: compile-time error
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t04.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t04.dart
index 4de478e..4f64999 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t04.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l1_t04.dart
@@ -42,8 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiation to bounds works OK for the class with
- * [typedef G<X> = X Function()] parameter (contravariant)
+ * @description Checks that instantiation to bounds works OK for non-function
+ * typedef with [typedef G<X> = void Function()] type parameter: [typedef G<X> =
+ * void Function(); class C<X>; typedef A<X extends G<C<X>>> = C<X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -59,19 +60,19 @@
 main() {
   A source;
   var fsource = toF(source);
-  F<A<G<A<dynamic>>>> target = fsource;
+  F<A<G<C<dynamic>>>> target = fsource;
 
-  F<A<G<A<Null>>>> target0 = fsource;
+  F<A<G<C<Null>>>> target0 = fsource;
 
   F<A<dynamic>> target1 = fsource;          //# 01: compile-time error
   F<A<G<dynamic>>> target2 = fsource;
-  F<A<G<A<G<dynamic>>>>> target3 = fsource;
-  F<A<G<A<G<A<dynamic>>>>>> target4 = fsource;
+  F<A<G<C<G<dynamic>>>>> target3 = fsource;
+  F<A<G<C<G<C<dynamic>>>>>> target4 = fsource;
 
   F<A<Null>> target5 = fsource;             //# 02: compile-time error
   F<A<G<Null>>> target6 = fsource;
-  F<A<G<A<G<Null>>>>> target7 = fsource;
-  F<A<G<A<G<A<Null>>>>>> target8 = fsource;
+  F<A<G<C<G<Null>>>>> target7 = fsource;
+  F<A<G<C<G<C<Null>>>>>> target8 = fsource;
 
   A();
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t01.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t01.dart
index 3cea9ee..e80cd08 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t01.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t01.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiation to bounds works OK for [typedef G<X> =
- * X Function()], [typedef A<X extends G<A<X, Y>>, Y extends X>]
+ * X Function(); class C<X, Y>; typedef A<X extends G<C<X, Y>>, Y extends X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -58,11 +58,11 @@
 main() {
   A source;
   var fsource = toF(source);
-  F<A<G<A<dynamic, dynamic>>, dynamic>> target = fsource;
+  F<A<G<C<dynamic, dynamic>>, dynamic>> target = fsource;
 
   F<A<dynamic, dynamic>> target1 = fsource;                   //# 01: compile-time error
   F<A<G<dynamic>, dynamic>> target2 = fsource;                //# 02: compile-time error
-  F<A<G<A<G<dynamic>, dynamic>>, dynamic>> target3 = fsource; //# 03: compile-time error
+  F<A<G<C<G<dynamic>, dynamic>>, dynamic>> target3 = fsource; //# 03: compile-time error
 
   A();                                                        //# 04: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t02.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t02.dart
index 4b423cc..f9689ef 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t02.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t02.dart
@@ -43,24 +43,8 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiation to bounds works OK for [typedef G<X> =
- * Function(X)], [class A<X extends G<A<X, Y>>, Y extends X>]
- *
- * In the test we have [G] with one type argument which is contravariant, so the
- * meaning of the raw [A] is [A<G<A<Null, Null>>, dynamic>], obtained as
- * follows:
- *
- * X                  Y
- * ----------------------------------
- * G<A<X, Y>>         X             // Initial values.
- * G<A<Null, Null>>   dynamic       // Break SCC {X, Y}.
- *
- * The resulting type is well-bounded, because it is super-bounded, because
- * [dynamic <: G<...>] fails, but [A<G<A<Object, Object>>, Null>] is
- * regular-bounded, because [Null <: ...` and `G<A<Object, Object>> <:
- * G<A<..., ...>>].
- * This also shows that the instance creation at the end is a compile-time
- * error.
- *
+ * Function(X); class C<X, Y>; typedef A<X extends G<C<X,Y>>, Y extends X> =
+ * C<X, Y>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -75,11 +59,11 @@
 main() {
   A source;
   var fsource = toF(source);
-  F<A<G<A<Null, Null>>, dynamic>> target = fsource;
+  F<A<G<C<Null, Null>>, dynamic>> target = fsource;
 
   F<A<dynamic, dynamic>> target1 = fsource;                   //# 01: compile-time error
   F<A<G<dynamic>, dynamic>> target2 = fsource;                //# 02: compile-time error
-  F<A<G<A<G<dynamic>, dynamic>>, dynamic>> target3 = fsource; //# 03: compile-time error
+  F<A<G<C<G<dynamic>, dynamic>>, dynamic>> target3 = fsource; //# 03: compile-time error
 
   A();                                                        //# 04: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t03.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t03.dart
index 4d15484..3133557 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t03.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t03.dart
@@ -42,8 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiation to bounds works OK for [typedef G<X> =
- * X Function(X)], [typedef A<X extends G<A<X, Y>>, Y extends X>]
+ * @description Checks that instantiation to bounds works OK for [class C<X, Y>;
+ * typedef G<X> = X Function(X); typedef A<X extends G<A<X, Y>>, Y extends X> =
+ * C<X, Y>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -53,7 +54,7 @@
 
 class C<X, Y> {}
 typedef G<X> = X Function(X);
-typedef A<X extends G<A<X, Y>>, Y extends X> = C<X, Y>;
+typedef A<X extends G<C<X, Y>>, Y extends X> = C<X, Y>;
 
 main() {
   A source;  //# 01: compile-time error
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t04.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t04.dart
index 816267c..e337a9d 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t04.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t04.dart
@@ -43,7 +43,7 @@
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
  * @description Checks that instantiation to bounds works OK for [typedef G<X> =
- * void Function()], [typedef A<X extends G<C<X,Y>>, Y extends X>]
+ * void Function(); typedef A<X extends G<C<X,Y>>, Y extends X>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -58,11 +58,11 @@
 main() {
   A source;
   var fsource = toF(source);
-  F<A<G<A<dynamic, dynamic>>, dynamic>> target = fsource;
+  F<A<G<C<dynamic, dynamic>>, dynamic>> target = fsource;
 
   F<A<dynamic, dynamic>> target1 = fsource;           //# 01: compile-time error
   F<A<G<dynamic>, dynamic>> target2 = fsource;
-  F<A<G<A<G<dynamic>, dynamic>>, dynamic>> target3 = fsource;
+  F<A<G<C<G<dynamic>, dynamic>>, dynamic>> target3 = fsource;
 
   A();
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t05.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t05.dart
index 63a4d25..bb33ef8 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t05.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t05.dart
@@ -42,8 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiation to bounds works OK for [typedef G<X> =
- * X Function()], [typedef A<X extends G<A<Y, X>>, Y extends G<A<X, Y>>>]
+ * @description Checks that instantiation to bounds works OK for [class C<X,Y>;
+ * typedef G<X> = X Function(); typedef A<X extends G<A<Y, X>>, Y extends G<A<X,
+ * Y>>> = C<X, Y>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -58,13 +59,13 @@
 main() {
   A source;
   var fsource = toF(source);
-  F<A<G<A<dynamic, dynamic>>, G<A<dynamic, dynamic>>>> target = fsource;
+  F<A<G<C<dynamic, dynamic>>, G<C<dynamic, dynamic>>>> target = fsource;
 
-  F<A<dynamic, G<A<dynamic, dynamic>>>> target1 = fsource;                   //# 01: compile-time error
-  F<A<G<dynamic>, G<A<dynamic, dynamic>>>> target2 = fsource;                //# 02: compile-time error
-  F<A<G<A<G<dynamic>, dynamic>>, G<A<dynamic, dynamic>>>> target3 = fsource; //# 03: compile-time error
-  F<A<G<A<dynamic, dynamic>>, dynamic>> target4 = fsource;                   //# 04: compile-time error
-  F<A<G<A<dynamic, dynamic>>, G<dynamic>>> target5 = fsource;                //# 05: compile-time error
+  F<A<dynamic, G<C<dynamic, dynamic>>>> target1 = fsource;                   //# 01: compile-time error
+  F<A<G<dynamic>, G<C<dynamic, dynamic>>>> target2 = fsource;                //# 02: compile-time error
+  F<A<G<C<G<dynamic>, dynamic>>, G<C<dynamic, dynamic>>>> target3 = fsource; //# 03: compile-time error
+  F<A<G<C<dynamic, dynamic>>, dynamic>> target4 = fsource;                   //# 04: compile-time error
+  F<A<G<C<dynamic, dynamic>>, G<dynamic>>> target5 = fsource;                //# 05: compile-time error
 
   A();  //# 06: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t06.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t06.dart
index 4b8400c..d3bcdfa 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t06.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t06.dart
@@ -42,8 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiation to bounds works OK for [typedef G<X> =
- * Function(X)], [class A<X extends G<A<Y, X>>, Y extends G<A<X, Y>>>]
+ * @description Checks that instantiation to bounds works OK for [class C<X, Y>;
+ * typedef G<X> = Function(X); typedef A<X extends G<C<Y, X>>, Y extends G<C<X,
+ * Y>>> = C<X, Y>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -58,15 +59,15 @@
 main() {
   A source;
   var fsource = toF(source);
-  F<A<G<A<Null, Null>>, G<A<Null, Null>>>> target = fsource;
+  F<A<G<C<Null, Null>>, G<C<Null, Null>>>> target = fsource;
 
 
-  F<A<G<A<dynamic, dynamic>>, G<A<dynamic, dynamic>>>> target1 = fsource;    //# 01: compile-time error
-  F<A<dynamic, G<A<dynamic, dynamic>>>> target2 = fsource;                   //# 02: compile-time error
-  F<A<G<dynamic>, G<A<dynamic, dynamic>>>> target3 = fsource;                //# 03: compile-time error
-  F<A<G<A<G<dynamic>, dynamic>>, G<A<dynamic, dynamic>>>> target4 = fsource; //# 04: compile-time error
-  F<A<G<A<dynamic, dynamic>>, dynamic>> target5 = fsource;                   //# 05: compile-time error
-  F<A<G<A<dynamic, dynamic>>, G<dynamic>>> target6 = fsource;                //# 06: compile-time error
+  F<A<G<C<dynamic, dynamic>>, G<C<dynamic, dynamic>>>> target1 = fsource;    //# 01: compile-time error
+  F<A<dynamic, G<C<dynamic, dynamic>>>> target2 = fsource;                   //# 02: compile-time error
+  F<A<G<dynamic>, G<C<dynamic, dynamic>>>> target3 = fsource;                //# 03: compile-time error
+  F<A<G<C<G<dynamic>, dynamic>>, G<C<dynamic, dynamic>>>> target4 = fsource; //# 04: compile-time error
+  F<A<G<C<dynamic, dynamic>>, dynamic>> target5 = fsource;                   //# 05: compile-time error
+  F<A<G<C<dynamic, dynamic>>, G<dynamic>>> target6 = fsource;                //# 06: compile-time error
 
   A();                                                                       //# 07: compile-time error
 }
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t07.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t07.dart
index e8d1bfa..ff8215f 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t07.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t07.dart
@@ -42,8 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiation to bounds works OK for [typedef G<X> =
- * X Function()], [class A<X extends G<A<Y, X>>, Y extends G<A<X, Y>>>]
+ * @description Checks that instantiation to bounds works OK for [class C<X, Y>;
+ * typedef G<X> = X Function(X); typedef A<X extends G<C<Y, X>>, Y extends
+ * G<C<X, Y>>> = C<X, Y>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -53,7 +54,7 @@
 
 class C<X, Y> {}
 typedef G<X> = X Function(X);
-typedef A<X extends G<A<Y, X>>, Y extends G<A<X, Y>>> = C<X, Y>;
+typedef A<X extends G<C<Y, X>>, Y extends G<C<X, Y>>> = C<X, Y>;
 
 main() {
   A source; //# 01: compile-time error
diff --git a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t08.dart b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t08.dart
index a2824c0..792f7ce 100644
--- a/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t08.dart
+++ b/LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/nonfunction_typedef_l2_t08.dart
@@ -42,8 +42,9 @@
  *
  *   3. Otherwise, (when no dependencies exist) terminate with the result
  *   [<U1,m ..., Uk,m>].
- * @description Checks that instantiation to bounds works OK for [typedef G<X> =
- * void Function()], [typedef A<X extends G<A<Y, X>>, Y extends G<A<X, Y>>>]
+ * @description Checks that instantiation to bounds works OK for [class C<X, Y>;
+    typedef G<X> = void Function(); typedef A<X extends G<C<Y, X>>, Y extends
+    G<C<X, Y>>> = C<X, Y>].
  * @author iarkh@unipro.ru
  */
 // SharedOptions=--enable-experiment=nonfunction-type-aliases
@@ -58,13 +59,13 @@
 main() {
   A source;
   var fsource = toF(source);
-  F<A<G<A<dynamic, dynamic>>, G<A<dynamic, dynamic>>>> target = fsource;
+  F<A<G<C<dynamic, dynamic>>, G<C<dynamic, dynamic>>>> target = fsource;
 
-  F<A<dynamic, G<A<dynamic, dynamic>>>> target1 = fsource;                   //# 01: compile-time error
-  F<A<G<dynamic>, G<A<dynamic, dynamic>>>> target2 = fsource;
-  F<A<G<A<G<dynamic>, dynamic>>, G<A<dynamic, dynamic>>>> target3 = fsource;
-  F<A<G<A<dynamic, dynamic>>, dynamic>> target4 = fsource;                   //# 02: compile-time error
-  F<A<G<A<dynamic, dynamic>>, G<dynamic>>> target5 = fsource;
+  F<A<dynamic, G<C<dynamic, dynamic>>>> target1 = fsource;                   //# 01: compile-time error
+  F<A<G<dynamic>, G<C<dynamic, dynamic>>>> target2 = fsource;
+  F<A<G<C<G<dynamic>, dynamic>>, G<C<dynamic, dynamic>>>> target3 = fsource;
+  F<A<G<C<dynamic, dynamic>>, dynamic>> target4 = fsource;                   //# 02: compile-time error
+  F<A<G<C<dynamic, dynamic>>, G<dynamic>>> target5 = fsource;
 
   A();
 }